diff --git a/Services/RequestServer/ConnectionFromClient.cpp b/Services/RequestServer/ConnectionFromClient.cpp
index 48ed36e4292..fd524f53d53 100644
--- a/Services/RequestServer/ConnectionFromClient.cpp
+++ b/Services/RequestServer/ConnectionFromClient.cpp
@@ -55,6 +55,8 @@ static NonnullRefPtr<Resolver> default_resolver()
 
         if (g_dns_info.use_dns_over_tls) {
             TLS::Options options;
+            options.set_blocking(false);
+
             if (!g_default_certificate_path.is_empty())
                 options.set_root_certificates_path(g_default_certificate_path);
 
diff --git a/Tests/LibDNS/TestDNSResolver.cpp b/Tests/LibDNS/TestDNSResolver.cpp
index f22d2685cb8..7551a831595 100644
--- a/Tests/LibDNS/TestDNSResolver.cpp
+++ b/Tests/LibDNS/TestDNSResolver.cpp
@@ -18,13 +18,13 @@ TEST_CASE(test_udp)
         [&] -> ErrorOr<DNS::Resolver::SocketResult> {
             Core::SocketAddress addr = { IPv4Address::from_string("1.1.1.1"sv).value(), static_cast<u16>(53) };
             return DNS::Resolver::SocketResult {
-                MUST(Core::BufferedSocket<Core::UDPSocket>::create(MUST(Core::UDPSocket::connect(addr)))),
+                TRY(Core::BufferedSocket<Core::UDPSocket>::create(TRY(Core::UDPSocket::connect(addr)))),
                 DNS::Resolver::ConnectionMode::UDP,
             };
         }
     };
 
-    MUST(resolver.when_socket_ready()->await());
+    TRY_OR_FAIL(resolver.when_socket_ready()->await());
 
     resolver.lookup("google.com", DNS::Messages::Class::IN, { DNS::Messages::ResourceType::A, DNS::Messages::ResourceType::AAAA })
         ->when_resolved([&](auto& result) {
@@ -46,14 +46,18 @@ TEST_CASE(test_tcp)
     DNS::Resolver resolver {
         [&] -> ErrorOr<DNS::Resolver::SocketResult> {
             Core::SocketAddress addr = { IPv4Address::from_string("1.1.1.1"sv).value(), static_cast<u16>(53) };
+
+            auto tcp_socket = TRY(Core::TCPSocket::connect(addr));
+            TRY(tcp_socket->set_blocking(false));
+
             return DNS::Resolver::SocketResult {
-                MUST(Core::BufferedSocket<Core::TCPSocket>::create(MUST(Core::TCPSocket::connect(addr)))),
+                TRY(Core::BufferedSocket<Core::TCPSocket>::create(move(tcp_socket))),
                 DNS::Resolver::ConnectionMode::TCP,
             };
         }
     };
 
-    MUST(resolver.when_socket_ready()->await());
+    TRY_OR_FAIL(resolver.when_socket_ready()->await());
 
     resolver.lookup("google.com", DNS::Messages::Class::IN, { DNS::Messages::ResourceType::A, DNS::Messages::ResourceType::AAAA })
         ->when_resolved([&](auto& result) {
@@ -91,6 +95,7 @@ TEST_CASE(test_tls)
 
             TLS::Options options;
             options.set_root_certificates_path(locate_ca_certs_file());
+            options.set_blocking(false);
 
             return DNS::Resolver::SocketResult {
                 MaybeOwned<Core::Socket>(TRY(TLS::TLSv12::connect(addr, "1.1.1.1", move(options)))),
@@ -99,7 +104,7 @@ TEST_CASE(test_tls)
         }
     };
 
-    MUST(resolver.when_socket_ready()->await());
+    TRY_OR_FAIL(resolver.when_socket_ready()->await());
 
     resolver.lookup("google.com", DNS::Messages::Class::IN, { DNS::Messages::ResourceType::A, DNS::Messages::ResourceType::AAAA })
         ->when_resolved([&](auto& result) {
diff --git a/Utilities/dns.cpp b/Utilities/dns.cpp
index 9f5623302e7..45a8b50f150 100644
--- a/Utilities/dns.cpp
+++ b/Utilities/dns.cpp
@@ -73,36 +73,35 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
 
     DNS::Resolver resolver {
         [&] -> ErrorOr<DNS::Resolver::SocketResult> {
-            Core::SocketAddress addr;
-            if (auto v4 = IPv4Address::from_string(server_address); v4.has_value()) {
-                addr = { v4.value(), static_cast<u16>(use_tls ? 853 : 53) };
-            } else if (auto v6 = IPv6Address::from_string(server_address); v6.has_value()) {
-                addr = { v6.value(), static_cast<u16>(use_tls ? 853 : 53) };
-            } else {
-                return MUST(resolver.lookup(server_address)->await())->cached_addresses().first().visit([&](auto& address) -> DNS::Resolver::SocketResult {
-                    if (use_tls) {
-                        TLS::Options options;
-                        options.set_root_certificates_path(cert_path);
+            auto make_resolver = [&](Core::SocketAddress const& address) -> ErrorOr<DNS::Resolver::SocketResult> {
+                if (use_tls) {
+                    TLS::Options options;
+                    options.set_root_certificates_path(cert_path);
+                    options.set_blocking(false);
 
-                        auto tls = MUST(TLS::TLSv12::connect({ address, 853 }, server_address, move(options)));
-                        return { move(tls), DNS::Resolver::ConnectionMode::TCP };
-                    }
-                    return { MUST(Core::BufferedSocket<Core::UDPSocket>::create(MUST(Core::UDPSocket::connect({ address, 53 })))), DNS::Resolver::ConnectionMode::UDP };
+                    auto tls = TRY(TLS::TLSv12::connect(address, server_address, move(options)));
+                    return DNS::Resolver::SocketResult { move(tls), DNS::Resolver::ConnectionMode::TCP };
+                }
+
+                return DNS::Resolver::SocketResult {
+                    TRY(Core::BufferedSocket<Core::UDPSocket>::create(TRY(Core::UDPSocket::connect(address)))),
+                    DNS::Resolver::ConnectionMode::UDP,
+                };
+            };
+
+            if (auto v4 = IPv4Address::from_string(server_address); v4.has_value()) {
+                return make_resolver({ v4.value(), static_cast<u16>(use_tls ? 853 : 53) });
+            } else if (auto v6 = IPv6Address::from_string(server_address); v6.has_value()) {
+                return make_resolver({ v6.value(), static_cast<u16>(use_tls ? 853 : 53) });
+            } else {
+                return TRY(resolver.lookup(server_address)->await())->cached_addresses().first().visit([&](auto& address) {
+                    return make_resolver({ address, static_cast<u16>(use_tls ? 853 : 53) });
                 });
             }
-
-            if (use_tls) {
-                TLS::Options options;
-                options.set_root_certificates_path(cert_path);
-
-                return DNS::Resolver::SocketResult { MUST(TLS::TLSv12::connect(addr, server_address, move(options))), DNS::Resolver::ConnectionMode::TCP };
-            }
-
-            return DNS::Resolver::SocketResult { MUST(Core::BufferedSocket<Core::UDPSocket>::create(MUST(Core::UDPSocket::connect(addr)))), DNS::Resolver::ConnectionMode::UDP };
         }
     };
 
-    MUST(resolver.when_socket_ready()->await());
+    TRY(resolver.when_socket_ready()->await());
 
     size_t pending_requests = requests.size();
     for (auto& request : requests) {