diff --git a/common/client-core/src/client/topology_control/accessor.rs b/common/client-core/src/client/topology_control/accessor.rs
index f4b50be059..7b78da0a6a 100644
--- a/common/client-core/src/client/topology_control/accessor.rs
+++ b/common/client-core/src/client/topology_control/accessor.rs
@@ -132,7 +132,10 @@ impl TopologyAccessor {
     }
 
     pub async fn current_topology(&self) -> Option<NymTopology> {
-        self.inner.topology.read().await.clone()
+        let read_lock = self.inner.topology.read().await;
+        let topology = read_lock.clone();
+        drop(read_lock);
+        topology
     }
 
     pub async fn manually_change_topology(&self, new_topology: NymTopology) {
diff --git a/common/client-libs/mixnet-client/src/client.rs b/common/client-libs/mixnet-client/src/client.rs
index f5871774db..949ac9f59c 100644
--- a/common/client-libs/mixnet-client/src/client.rs
+++ b/common/client-libs/mixnet-client/src/client.rs
@@ -112,18 +112,26 @@ impl Client {
                     // if we managed to connect, reset the reconnection count (whatever it might have been)
                     current_reconnection.store(0, Ordering::Release);
                     //Get the topology, because we need the keys for the handshake
-                    let topology_permit = topology_access.get_read_permit().await;
-                    let topology_ref = match topology_permit.try_get_raw_topology_ref() {
-                        Ok(topology) => topology,
-                        Err(err) => {
-                            error!("Cannot perform Noise handshake to {address}, due to topology error - {err}");
+                    // let topology_permit = topology_access.get_read_permit().await;
+                    // let topology_ref = match topology_permit.try_get_raw_topology_ref() {
+                    //     Ok(topology) => topology,
+                    //     Err(err) => {
+                    //         error!("Cannot perform Noise handshake to {address}, due to topology error - {err}");
+                    //         return;
+                    //     }
+                    // };
+
+                    let topology_ref = match topology_access.current_topology().await {
+                        Some(topology) => topology,
+                        None => {
+                            error!("Cannot perform Noise handshake to {address}, due to topology error");
                             return;
                         }
                     };
 
                     let noise_stream = match upgrade_noise_initiator_with_topology(
                         stream,
-                        topology_ref,
+                        &topology_ref,
                         local_public_key,
                         local_private_key,
                     )
diff --git a/gateway/src/node/mixnet_handling/receiver/connection_handler.rs b/gateway/src/node/mixnet_handling/receiver/connection_handler.rs
index cda72fa990..54a8e97ace 100644
--- a/gateway/src/node/mixnet_handling/receiver/connection_handler.rs
+++ b/gateway/src/node/mixnet_handling/receiver/connection_handler.rs
@@ -196,18 +196,26 @@ impl<St: Storage> ConnectionHandler<St> {
         shutdown.mark_as_success();
 
         let topology_access_clonne = self.topology_access.clone();
-        let topology_permit = topology_access_clonne.get_read_permit().await;
-        let topology_ref = match topology_permit.try_get_raw_topology_ref() {
-            Ok(topology) => topology,
-            Err(err) => {
-                error!("Cannot connect to {remote}, due to topology error - {err}");
+        // let topology_permit = topology_access_clonne.get_read_permit().await;
+        // let topology_ref = match topology_permit.try_get_raw_topology_ref() {
+        //     Ok(topology) => topology,
+        //     Err(err) => {
+        //         error!("Cannot connect to {remote}, due to topology error - {err}");
+        //         return;
+        //     }
+        // };
+
+        let topology_ref = match topology_access_clonne.current_topology().await {
+            Some(topology) => topology,
+            None => {
+                error!("Cannot perform Noise handshake to {remote}, due to topology error");
                 return;
             }
         };
 
         let noise_stream = match upgrade_noise_responder_with_topology(
             conn,
-            topology_ref,
+            &topology_ref,
             &self.local_identity.public_key().to_bytes(),
             &self.local_identity.private_key().to_bytes(),
         )
diff --git a/mixnode/src/node/listener/connection_handler/mod.rs b/mixnode/src/node/listener/connection_handler/mod.rs
index 5540a341ee..a4275a1dca 100644
--- a/mixnode/src/node/listener/connection_handler/mod.rs
+++ b/mixnode/src/node/listener/connection_handler/mod.rs
@@ -98,18 +98,26 @@ impl ConnectionHandler {
 
         shutdown.mark_as_success();
 
-        let topology_permit = self.topology_access.get_read_permit().await;
-        let topology_ref = match topology_permit.try_get_raw_topology_ref() {
-            Ok(topology) => topology,
-            Err(err) => {
-                error!("Cannot connect to {remote}, due to topology error - {err}");
+        // let topology_permit = self.topology_access.get_read_permit().await;
+        // let topology_ref = match topology_permit.try_get_raw_topology_ref() {
+        //     Ok(topology) => topology,
+        //     Err(err) => {
+        //         error!("Cannot connect to {remote}, due to topology error - {err}");
+        //         return;
+        //     }
+        // };
+
+        let topology_ref = match self.topology_access.current_topology().await {
+            Some(topology) => topology,
+            None => {
+                error!("Cannot perform Noise handshake to {remote}, due to topology error");
                 return;
             }
         };
 
         let noise_stream = match upgrade_noise_responder_with_topology(
             conn,
-            topology_ref,
+            &topology_ref,
             &self.local_identity.public_key().to_bytes(),
             &self.local_identity.private_key().to_bytes(),
         )