         let connection = Connection.connect(
             for: self,
             host: host
-        ).map { connection -> PooledConnection in
-            connection.slaveOk = self.slaveOk
-            
-            /// Ensures we default to the cluster's lowest version
-            if let connectionHandshake = connection.handshakeResult {
-                if let clusterHandshake = self.handshakeResult {
-                    if clusterHandshake.maxWireVersion.version > connectionHandshake.maxWireVersion.version {
-                        self.handshakeResult = connectionHandshake
-                    }
-                } else {
-                    self.handshakeResult = connectionHandshake
-                }
+            ).map { connection -> PooledConnection in
+                connection.slaveOk = self.slaveOk
                 
-                self.updateSDAM(from: connectionHandshake)
-            }
-            
-            let connectionId = ObjectIdentifier(connection)
-            connection.channel.closeFuture.whenComplete { [weak self] in
-                guard let me = self else { return }
+                /// Ensures we default to the cluster's lowest version
+                if let connectionHandshake = connection.handshakeResult {
+                    self.updateSDAM(from: connectionHandshake)
+                }
                 
-                me.remove(connectionId: connectionId)
-            }
-            
-            return PooledConnection(host: host, connection: connection)
+                let connectionId = ObjectIdentifier(connection)
+                connection.channel.closeFuture.whenComplete { [weak self] in
+                    guard let me = self else { return }
+                    
+                    me.remove(connectionId: connectionId)
+                }
+                
+                return PooledConnection(host: host, connection: connection)
         }
         
         connection.whenFailure { error in

        nextConnection: for pooledConnection in pool {
            let connection = pooledConnection.connection
            
            if connection.context.isClosed {
                self.remove(connectionId: ObjectIdentifier(connection))
                continue nextConnection
            }
            
            let unwritable = writable && handshakeResult?.readOnly ?? false
            let unreadable = !self.slaveOk && !(handshakeResult?.ismaster ?? false)
            
            if unwritable || unreadable {
                continue nextConnection

    let settings: ConnectionSettings
    let sessionManager: SessionManager
    
    /// The shared ObjectId generator for this cluster
    /// Using the shared generator is more efficient and correct than `ObjectId()`
    internal let sharedGenerator = ObjectIdGenerator()
