diff --git a/actix-server/src/accept.rs b/actix-server/src/accept.rs
index f5484434..24c2f91f 100644
--- a/actix-server/src/accept.rs
+++ b/actix-server/src/accept.rs
@@ -238,16 +238,22 @@ impl Accept {
 
     fn process_timer(&self, sockets: &mut Slab<ServerSocketInfo>) {
         let now = Instant::now();
-        sockets.iter_mut().for_each(|(token, info)| {
-            // only the ServerSocketInfo have an associate timeout value was de registered.
-            if let Some(inst) = info.timeout.take() {
-                if now > inst {
-                    self.register_logged(token, info);
-                } else {
+        sockets
+            .iter_mut()
+            // Only the ServerSocketInfo have an associate timeout value was de registered.
+            .filter(|(token, info)| info.timeout.is_some())
+            .for_each(|(token, info)| {
+                let inst = info.timeout.take().unwrap();
+
+                if now < inst {
                     info.timeout = Some(inst);
+                } else if !self.backpressure {
+                    self.register_logged(token, info);
                 }
-            }
-        });
+                // Drop the timeout if server is in backpressure and socket timeout is expired.
+                // When server is recovered from backpressure it would register all socket without
+                // a timeout value so this socket register would be delayed till then.
+            });
     }
 
     #[cfg(not(target_os = "windows"))]
@@ -301,20 +307,22 @@ impl Accept {
     }
 
     fn maybe_backpressure(&mut self, sockets: &mut Slab<ServerSocketInfo>, on: bool) {
-        if self.backpressure {
-            if !on {
+        // Only operate when server is in a different backpressure than the given flag.
+        if self.backpressure != on {
+            if on {
+                self.backpressure = true;
+                // TODO: figure out if timing out sockets can be safely de-registered twice.
+                self.deregister_all(sockets);
+            } else {
                 self.backpressure = false;
-                for (token, info) in sockets.iter_mut() {
-                    if info.timeout.is_some() {
-                        // socket will attempt to re-register itself when its timeout completes
-                        continue;
-                    }
-                    self.register_logged(token, info);
-                }
+                sockets
+                    .iter_mut()
+                    // Only operate on socket without associated timeout.
+                    // Socket info with it would attempt to re-register itself when its timeout
+                    // expire.
+                    .filter(|(_, info)| info.timeout.is_none())
+                    .for_each(|(token, info)| self.register_logged(token, info));
             }
-        } else if on {
-            self.backpressure = true;
-            self.deregister_all(sockets);
         }
     }