diff --git a/client_http.hpp b/client_http.hpp
index 47accb1..4466043 100644
--- a/client_http.hpp
+++ b/client_http.hpp
@@ -127,8 +127,10 @@ namespace SimpleWeb {
       }
 
       void cancel_timeout() noexcept {
-        if(timer)
-          timer->cancel();
+        if(timer) {
+          error_code ec;
+          timer->cancel(ec);
+        }
       }
     };
 
@@ -214,7 +216,7 @@ namespace SimpleWeb {
     /// Asynchronous request where setting and/or running Client's io_service is required.
     /// Do not use concurrently with the synchronous request functions.
     void request(const std::string &method, const std::string &path, string_view content, const CaseInsensitiveMultimap &header,
-                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback_) noexcept {
+                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback_) {
       auto session = std::make_shared<Session>(get_connection(), create_request_header(method, path, header));
       auto response = session->response;
       auto request_callback = std::make_shared<std::function<void(std::shared_ptr<Response>, const error_code &)>>(std::move(request_callback_));
@@ -256,24 +258,24 @@ namespace SimpleWeb {
     /// Asynchronous request where setting and/or running Client's io_service is required.
     /// Do not use concurrently with the synchronous request functions.
     void request(const std::string &method, const std::string &path, string_view content,
-                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) noexcept {
+                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
       request(method, path, content, CaseInsensitiveMultimap(), std::move(request_callback));
     }
 
     /// Asynchronous request where setting and/or running Client's io_service is required.
     void request(const std::string &method, const std::string &path,
-                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) noexcept {
+                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
       request(method, path, std::string(), CaseInsensitiveMultimap(), std::move(request_callback));
     }
 
     /// Asynchronous request where setting and/or running Client's io_service is required.
-    void request(const std::string &method, std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) noexcept {
+    void request(const std::string &method, std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
       request(method, std::string("/"), std::string(), CaseInsensitiveMultimap(), std::move(request_callback));
     }
 
     /// Asynchronous request where setting and/or running Client's io_service is required.
     void request(const std::string &method, const std::string &path, std::istream &content, const CaseInsensitiveMultimap &header,
-                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback_) noexcept {
+                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback_) {
       auto session = std::make_shared<Session>(get_connection(), create_request_header(method, path, header));
       auto response = session->response;
       auto request_callback = std::make_shared<std::function<void(std::shared_ptr<Response>, const error_code &)>>(std::move(request_callback_));
@@ -318,7 +320,7 @@ namespace SimpleWeb {
 
     /// Asynchronous request where setting and/or running Client's io_service is required.
     void request(const std::string &method, const std::string &path, std::istream &content,
-                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) noexcept {
+                 std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
       request(method, path, content, CaseInsensitiveMultimap(), std::move(request_callback));
     }
 
@@ -394,9 +396,9 @@ namespace SimpleWeb {
     }
 
     virtual std::shared_ptr<Connection> create_connection() noexcept = 0;
-    virtual void connect(const std::shared_ptr<Session> &) noexcept = 0;
+    virtual void connect(const std::shared_ptr<Session> &) = 0;
 
-    std::unique_ptr<asio::streambuf> create_request_header(const std::string &method, const std::string &path, const CaseInsensitiveMultimap &header) const noexcept {
+    std::unique_ptr<asio::streambuf> create_request_header(const std::string &method, const std::string &path, const CaseInsensitiveMultimap &header) const {
       auto corrected_path = path;
       if(corrected_path == "")
         corrected_path = "/";
@@ -426,7 +428,7 @@ namespace SimpleWeb {
       return parsed_host_port;
     }
 
-    void write(const std::shared_ptr<Session> &session) noexcept {
+    void write(const std::shared_ptr<Session> &session) {
       session->connection->set_timeout();
       asio::async_write(*session->connection->socket, session->request_buffer->data(), [this, session](const error_code &ec, size_t /*bytes_transferred*/) {
         session->connection->cancel_timeout();
@@ -440,7 +442,7 @@ namespace SimpleWeb {
       });
     }
 
-    void read(const std::shared_ptr<Session> &session) noexcept {
+    void read(const std::shared_ptr<Session> &session) {
       session->connection->set_timeout();
       asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n\r\n", [this, session](const error_code &ec, size_t bytes_transferred) {
         session->connection->cancel_timeout();
@@ -520,7 +522,7 @@ namespace SimpleWeb {
       });
     }
 
-    void read_chunked(const std::shared_ptr<Session> &session, const std::shared_ptr<asio::streambuf> &tmp_streambuf) noexcept {
+    void read_chunked(const std::shared_ptr<Session> &session, const std::shared_ptr<asio::streambuf> &tmp_streambuf) {
       session->connection->set_timeout();
       asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n", [this, session, tmp_streambuf](const error_code &ec, size_t bytes_transferred) {
         session->connection->cancel_timeout();
@@ -595,7 +597,7 @@ namespace SimpleWeb {
       return std::make_shared<Connection>(handler_runner, config.timeout, *io_service);
     }
 
-    void connect(const std::shared_ptr<Session> &session) noexcept override {
+    void connect(const std::shared_ptr<Session> &session) override {
       if(!session->connection->socket->lowest_layer().is_open()) {
         auto resolver = std::make_shared<asio::ip::tcp::resolver>(*io_service);
         session->connection->set_timeout(config.timeout_connect);
diff --git a/client_https.hpp b/client_https.hpp
index 3b24b70..785ad59 100644
--- a/client_https.hpp
+++ b/client_https.hpp
@@ -16,7 +16,7 @@ namespace SimpleWeb {
   class Client<HTTPS> : public ClientBase<HTTPS> {
   public:
     Client(const std::string &server_port_path, bool verify_certificate = true, const std::string &cert_file = std::string(),
-           const std::string &private_key_file = std::string(), const std::string &verify_file = std::string()) noexcept
+           const std::string &private_key_file = std::string(), const std::string &verify_file = std::string())
         : ClientBase<HTTPS>::ClientBase(server_port_path, 443), context(asio::ssl::context::tlsv12) {
       if(cert_file.size() > 0 && private_key_file.size() > 0) {
         context.use_certificate_chain_file(cert_file);
@@ -44,7 +44,7 @@ namespace SimpleWeb {
       return std::make_shared<Connection>(handler_runner, config.timeout, *io_service, context);
     }
 
-    void connect(const std::shared_ptr<Session> &session) noexcept override {
+    void connect(const std::shared_ptr<Session> &session) override {
       if(!session->connection->socket->lowest_layer().is_open()) {
         auto resolver = std::make_shared<asio::ip::tcp::resolver>(*io_service);
         resolver->async_resolve(*query, [this, session, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator it) {
@@ -116,7 +116,7 @@ namespace SimpleWeb {
         write(session);
     }
 
-    void handshake(const std::shared_ptr<Session> &session) noexcept {
+    void handshake(const std::shared_ptr<Session> &session) {
       session->connection->set_timeout(this->config.timeout_connect);
       session->connection->socket->async_handshake(asio::ssl::stream_base::client, [this, session](const error_code &ec) {
         session->connection->cancel_timeout();
diff --git a/server_http.hpp b/server_http.hpp
index 6efe9ff..7c19d80 100644
--- a/server_http.hpp
+++ b/server_http.hpp
@@ -62,7 +62,7 @@ namespace SimpleWeb {
       Response(std::shared_ptr<Session> session, long timeout_content) noexcept : std::ostream(&streambuf), session(std::move(session)), timeout_content(timeout_content) {}
 
       template <typename size_type>
-      void write_header(const CaseInsensitiveMultimap &header, size_type size) noexcept {
+      void write_header(const CaseInsensitiveMultimap &header, size_type size) {
         bool content_length_written = false;
         bool chunked_transfer_encoding = false;
         for(auto &field : header) {
@@ -99,18 +99,18 @@ namespace SimpleWeb {
       }
 
       /// Write directly to stream buffer using std::ostream::write
-      void write(const char_type *ptr, std::streamsize n) noexcept {
+      void write(const char_type *ptr, std::streamsize n) {
         std::ostream::write(ptr, n);
       }
 
       /// Convenience function for writing status line, potential header fields, and empty content
-      void write(StatusCode status_code = StatusCode::success_ok, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) noexcept {
+      void write(StatusCode status_code = StatusCode::success_ok, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
         *this << "HTTP/1.1 " << SimpleWeb::status_code(status_code) << "\r\n";
         write_header(header, 0);
       }
 
       /// Convenience function for writing status line, header fields, and content
-      void write(StatusCode status_code, const std::string &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) noexcept {
+      void write(StatusCode status_code, const std::string &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
         *this << "HTTP/1.1 " << SimpleWeb::status_code(status_code) << "\r\n";
         write_header(header, content.size());
         if(!content.empty())
@@ -118,7 +118,7 @@ namespace SimpleWeb {
       }
 
       /// Convenience function for writing status line, header fields, and content
-      void write(StatusCode status_code, std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) noexcept {
+      void write(StatusCode status_code, std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
         *this << "HTTP/1.1 " << SimpleWeb::status_code(status_code) << "\r\n";
         content.seekg(0, std::ios::end);
         auto size = content.tellg();
@@ -129,17 +129,17 @@ namespace SimpleWeb {
       }
 
       /// Convenience function for writing success status line, header fields, and content
-      void write(const std::string &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) noexcept {
+      void write(const std::string &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
         write(StatusCode::success_ok, content, header);
       }
 
       /// Convenience function for writing success status line, header fields, and content
-      void write(std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) noexcept {
+      void write(std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
         write(StatusCode::success_ok, content, header);
       }
 
       /// Convenience function for writing success status line, and header fields
-      void write(const CaseInsensitiveMultimap &header) noexcept {
+      void write(const CaseInsensitiveMultimap &header) {
         write(StatusCode::success_ok, std::string(), header);
       }
 
@@ -239,8 +239,10 @@ namespace SimpleWeb {
       }
 
       void cancel_timeout() noexcept {
-        if(timer)
-          timer->cancel();
+        if(timer) {
+          error_code ec;
+          timer->cancel(ec);
+        }
       }
     };
 
@@ -310,7 +312,7 @@ namespace SimpleWeb {
     /// If you have your own asio::io_service, store its pointer here before running start().
     std::shared_ptr<asio::io_service> io_service;
 
-    virtual void start() noexcept {
+    virtual void start() {
       if(!io_service) {
         io_service = std::make_shared<asio::io_service>();
         internal_io_service = true;
@@ -389,7 +391,7 @@ namespace SimpleWeb {
 
     ServerBase(unsigned short port) noexcept : config(port), connections(new std::unordered_set<Connection *>()), connections_mutex(new std::mutex()), handler_runner(new ScopeRunner()) {}
 
-    virtual void accept() noexcept = 0;
+    virtual void accept() = 0;
 
     template <typename... Args>
     std::shared_ptr<Connection> create_connection(Args &&... args) noexcept {
@@ -411,7 +413,7 @@ namespace SimpleWeb {
       return connection;
     }
 
-    void read_request_and_content(const std::shared_ptr<Session> &session) noexcept {
+    void read_request_and_content(const std::shared_ptr<Session> &session) {
       session->connection->set_timeout(config.timeout_request);
       asio::async_read_until(*session->connection->socket, session->request->streambuf, "\r\n\r\n", [this, session](const error_code &ec, size_t bytes_transferred) {
         session->connection->cancel_timeout();
@@ -468,7 +470,7 @@ namespace SimpleWeb {
       });
     }
 
-    void find_resource(const std::shared_ptr<Session> &session) noexcept {
+    void find_resource(const std::shared_ptr<Session> &session) {
       // Upgrade connection
       if(on_upgrade) {
         auto it = session->request->header.find("Upgrade");
@@ -503,7 +505,7 @@ namespace SimpleWeb {
     }
 
     void write_response(const std::shared_ptr<Session> &session,
-                        std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)> &resource_function) noexcept {
+                        std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)> &resource_function) {
       session->connection->set_timeout(config.timeout_content);
       auto response = std::shared_ptr<Response>(new Response(session, config.timeout_content), [this](Response *response_ptr) {
         auto response = std::shared_ptr<Response>(response_ptr);
@@ -555,7 +557,7 @@ namespace SimpleWeb {
     Server() noexcept : ServerBase<HTTP>::ServerBase(80) {}
 
   protected:
-    void accept() noexcept override {
+    void accept() override {
       auto session = std::make_shared<Session>(create_connection(*io_service));
 
       acceptor->async_accept(*session->connection->socket, [this, session](const error_code &ec) {
diff --git a/server_https.hpp b/server_https.hpp
index 2143601..51e3b62 100644
--- a/server_https.hpp
+++ b/server_https.hpp
@@ -21,7 +21,7 @@ namespace SimpleWeb {
     bool set_session_id_context = false;
 
   public:
-    Server(const std::string &cert_file, const std::string &private_key_file, const std::string &verify_file = std::string()) noexcept
+    Server(const std::string &cert_file, const std::string &private_key_file, const std::string &verify_file = std::string())
         : ServerBase<HTTPS>::ServerBase(443), context(asio::ssl::context::tlsv12) {
       context.use_certificate_chain_file(cert_file);
       context.use_private_key_file(private_key_file, asio::ssl::context::pem);
@@ -33,7 +33,7 @@ namespace SimpleWeb {
       }
     }
 
-    void start() noexcept override {
+    void start() override {
       if(set_session_id_context) {
         // Creating session_id_context from address:port but reversed due to small SSL_MAX_SSL_SESSION_ID_LENGTH
         session_id_context = std::to_string(config.port) + ':';
@@ -47,7 +47,7 @@ namespace SimpleWeb {
   protected:
     asio::ssl::context context;
 
-    void accept() noexcept override {
+    void accept() override {
       auto session = std::make_shared<Session>(create_connection(*io_service, context));
 
       acceptor->async_accept(session->connection->socket->lowest_layer(), [this, session](const error_code &ec) {