diff --git a/crates/radicle-node/src/control.rs b/crates/radicle-node/src/control.rs
index 0be586b2..434ff6c9 100644
--- a/crates/radicle-node/src/control.rs
+++ b/crates/radicle-node/src/control.rs
@@ -50,7 +50,7 @@ where
 
                 thread::spawn(&nid, "control", move || {
                     if let Err((e, mut stream)) = command(stream, handle) {
-                        log::error!(target: "control", "Command returned error: {e}");
+                        log::debug!(target: "control", "Command returned error: {e}");
 
                         CommandResult::error(e).to_writer(&mut stream).ok();
 
@@ -59,7 +59,7 @@ where
                     }
                 });
             }
-            Err(e) => log::error!(target: "control", "Failed to accept incoming connection: {e}"),
+            Err(e) => log::warn!(target: "control", "Failed to accept incoming connection: {e}"),
         }
     }
     log::debug!(target: "control", "Exiting control loop..");
diff --git a/crates/radicle-node/src/reactor.rs b/crates/radicle-node/src/reactor.rs
index 84a2bfd9..a9d09983 100644
--- a/crates/radicle-node/src/reactor.rs
+++ b/crates/radicle-node/src/reactor.rs
@@ -399,7 +399,7 @@ impl<H: ReactionHandler> Runtime<H> {
             }
 
             if let Err(err) = res {
-                log::error!(target: "reactor", "Error during polling: {err}");
+                log::warn!(target: "reactor", "Failure during polling: {err}");
                 self.service.handle_error(Error::Poll(err));
             }
 
@@ -497,7 +497,7 @@ impl<H: ReactionHandler> Runtime<H> {
             // Deadlock may happen here if the service will generate events over and over
             // in the handle_* calls we may never get out of this loop
             if let Err(err) = self.handle_action(action, instant) {
-                log::error!(target: "reactor", "Error: {err}");
+                log::warn!(target: "reactor", "Failure: {err}");
                 self.service.handle_error(err);
             }
         }
@@ -558,7 +558,7 @@ impl<H: ReactionHandler> Runtime<H> {
                         }
                     }
                 } else {
-                    log::error!(target: "reactor", token=token.0; "No transport with token {token:?} is known!");
+                    log::debug!(target: "reactor", token=token.0; "No transport with token {token:?} is known!");
                 }
             }
             Action::SetTimer(duration) => {
diff --git a/crates/radicle-node/src/reactor/transport.rs b/crates/radicle-node/src/reactor/transport.rs
index ef6e141a..8f0a1ea5 100644
--- a/crates/radicle-node/src/reactor/transport.rs
+++ b/crates/radicle-node/src/reactor/transport.rs
@@ -265,7 +265,7 @@ impl<S: Session> Transport<S> {
                         Ok(0)
                     },
                     _ => {
-                        log::error!(target: "transport", "Resource {} failed write operation with message '{err}'", self.display());
+                        log::warn!(target: "transport", "Resource {} failed write operation with message '{err}'", self.display());
                         Err(err)
                     },
                 }
diff --git a/crates/radicle-node/src/wire.rs b/crates/radicle-node/src/wire.rs
index de2f3ff4..67e87588 100644
--- a/crates/radicle-node/src/wire.rs
+++ b/crates/radicle-node/src/wire.rs
@@ -362,7 +362,7 @@ where
             }
             Entry::Occupied(mut e) => match e.get_mut() {
                 Peer::Disconnecting { nid, link, .. } => {
-                    log::error!(target: "wire", token=token.0; "Peer is already disconnecting");
+                    log::debug!(target: "wire", token=token.0; "Peer is already disconnecting");
 
                     nid.map(|n| (n, *link))
                 }
@@ -528,7 +528,7 @@ where
             Ok((connection, peer)) => {
                 let remote = NetAddr::from(peer);
                 let InetHost::Ip(ip) = remote.host else {
-                    log::error!(target: "wire", "Unexpected host type for inbound connection {remote}; dropping..");
+                    log::debug!(target: "wire", "Unexpected host type for inbound connection {remote}; dropping..");
                     drop(connection);
 
                     return;
@@ -552,7 +552,7 @@ where
                 let transport = match Transport::with_session(session, Link::Inbound) {
                     Ok(transport) => transport,
                     Err(err) => {
-                        log::error!(target: "wire", "Failed to create transport for accepted connection: {err}");
+                        log::warn!(target: "wire", "Failed to create transport for accepted connection: {err}");
                         return;
                     }
                 };
@@ -593,7 +593,7 @@ where
                 let nid: NodeId = state.remote_static_key.unwrap();
                 // Make sure we don't try to connect to ourselves by mistake.
                 if &nid == self.signer.public_key() {
-                    log::error!(target: "wire", "Self-connection detected, disconnecting..");
+                    log::warn!(target: "wire", "Self-connection detected, disconnecting..");
                     self.disconnect(token, DisconnectReason::SelfConnection);
 
                     return;
@@ -607,7 +607,7 @@ where
                     assert_eq!(nid, peer.nid);
                     (peer.addr, Link::Outbound)
                 } else {
-                    log::error!(target: "wire", token=token.0; "Session for {nid} not found");
+                    log::debug!(target: "wire", token=token.0; "Session for {nid} not found");
                     return;
                 };
                 log::debug!(
@@ -702,8 +702,8 @@ where
                     metrics.received_bytes += data.len();
 
                     if inbox.input(&data).is_err() {
-                        log::error!(target: "wire", "Maximum inbox size ({MAX_INBOX_SIZE}) reached for peer {nid}");
-                        log::error!(target: "wire", "Unable to process messages fast enough for peer {nid}; disconnecting..");
+                        log::warn!(target: "wire", "Maximum inbox size ({MAX_INBOX_SIZE}) reached for peer {nid}");
+                        log::warn!(target: "wire", "Unable to process messages fast enough for peer {nid}; disconnecting..");
                         self.disconnect(
                             token,
                             DisconnectReason::Session(session::Error::Misbehavior),
@@ -740,7 +740,7 @@ where
                                     channels,
                                 };
                                 if let Err(e) = self.worker.try_send(task) {
-                                    log::error!(
+                                    log::warn!(
                                         target: "wire",
                                         "Worker pool failed to accept incoming fetch request: {e}"
                                     );
@@ -754,7 +754,7 @@ where
                                     log::debug!(target: "wire", "Received `end-of-file` on stream {stream} from {nid}");
 
                                     if s.channels.send(ChannelEvent::Eof).is_err() {
-                                        log::error!(target: "wire", "Worker is disconnected; cannot send `EOF`");
+                                        log::debug!(target: "wire", "Worker is disconnected; cannot send `EOF`");
                                     }
                                 } else {
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");
@@ -791,7 +791,7 @@ where
                                     metrics.received_git_bytes += data.len();
 
                                     if s.channels.send(ChannelEvent::Data(data)).is_err() {
-                                        log::error!(target: "wire", "Worker is disconnected; cannot send data");
+                                        log::warn!(target: "wire", "Worker is disconnected; cannot send data");
                                     }
                                 } else {
                                     log::debug!(target: "wire", "Ignoring frame on closed or unknown stream {stream}");
@@ -802,7 +802,7 @@ where
                                 break;
                             }
                             Err(e) => {
-                                log::error!(target: "wire", "Invalid gossip message from {nid}: {e}");
+                                log::warn!(target: "wire", "Invalid gossip message from {nid}: {e}");
 
                                 if !inbox.is_empty() {
                                     log::debug!(target: "wire", "Dropping read buffer for {nid} with {} bytes", inbox.len());
@@ -875,7 +875,7 @@ where
     }
 
     fn handover_listener(&mut self, token: Token, _listener: Self::Listener) {
-        log::error!(target: "wire", token=token.0; "Listener handover is not supported");
+        log::warn!(target: "wire", token=token.0; "Listener handover is not supported");
     }
 
     fn handover_transport(&mut self, token: Token, transport: Self::Transport) {
@@ -933,7 +933,7 @@ where
                             continue;
                         }
                         None => {
-                            log::error!(target: "wire", "Dropping {} message(s) to {node_id}: unknown peer", msgs.len());
+                            log::debug!(target: "wire", "Dropping {} message(s) to {node_id}: unknown peer", msgs.len());
                             continue;
                         }
                     };
@@ -953,7 +953,7 @@ where
                 }
                 Io::Connect(node_id, addr) => {
                     if self.peers.connected().any(|(_, id)| id == &node_id) {
-                        log::error!(
+                        log::debug!(
                             target: "wire",
                             "Attempt to connect to already connected peer {node_id}"
                         );
@@ -1029,7 +1029,7 @@ where
                         // is in the service's i/o buffer. Since the service may not purge the
                         // buffer on disconnect, we should just ignore i/o actions that don't
                         // have a connected peer.
-                        log::error!(target: "wire", "Peer {remote} is not connected: dropping fetch");
+                        log::debug!(target: "wire", "Peer {remote} is not connected: dropping fetch");
                         continue;
                     };
                     let (stream, channels) =
@@ -1055,7 +1055,7 @@ where
                         );
                     }
                     if let Err(e) = self.worker.try_send(task) {
-                        log::error!(
+                        log::warn!(
                             target: "wire",
                             "Worker pool failed to accept outgoing fetch request: {e}"
                         );
@@ -1232,7 +1232,7 @@ mod logger {
             | NotConnected => {
                 log::info!(target: "wire", "Could not establish connection to {addr}: {err}")
             }
-            _ => log::error!(target: "wire", "Error establishing connection to {addr}: {err}"),
+            _ => log::warn!(target: "wire", "Failed to establish connection to {addr}: {err}"),
         }
     }
 }
diff --git a/crates/radicle-node/src/worker/fetch.rs b/crates/radicle-node/src/worker/fetch.rs
index 44a80338..f3fb13ed 100644
--- a/crates/radicle-node/src/worker/fetch.rs
+++ b/crates/radicle-node/src/worker/fetch.rs
@@ -106,7 +106,7 @@ impl Handle {
                 validations,
             } => {
                 for fail in validations.iter() {
-                    log::error!(target: "worker", "Validation error: {fail}");
+                    log::warn!(target: "worker", "Validation error: {fail}");
                 }
                 Err(error::Fetch::Validation {
                     threshold,
@@ -207,7 +207,7 @@ fn notify(
         if let RefUpdate::Skipped { .. } = update {
             // Don't notify about skipped refs.
         } else if let Err(e) = store.insert(rid, update, now) {
-            log::error!(
+            log::debug!(
                 target: "worker",
                 "Failed to update notification store for {rid}: {e}"
             );
@@ -227,7 +227,7 @@ where
         let name = r.name();
         let (namespace, qualified) = match radicle::git::parse_ref_namespaced(name) {
             Err(e) => {
-                log::error!(target: "worker", "Git reference is invalid: {name:?}: {e}");
+                log::debug!(target: "worker", "Git reference is invalid: {name:?}: {e}");
                 log::debug!(target: "worker", "Skipping refs caching for fetch of {repo}");
                 break;
             }
@@ -247,7 +247,7 @@ where
         };
 
         if let Err(e) = result {
-            log::error!(target: "worker", "Error updating git refs cache for {name:?}: {e}");
+            log::debug!(target: "worker", "Failed to update git refs cache for {name:?}: {e}");
             log::debug!(target: "worker", "Skipping refs caching for fetch of {repo}");
             break;
         }
@@ -326,7 +326,7 @@ where
         }
         Err(e) => {
             // Object was found, but failed to load. Fall-through.
-            log::error!(target: "fetch", "Error loading COB {tid} from storage: {e}");
+            log::debug!(target: "fetch", "Failed to load COB {tid} from storage: {e}");
         }
     }
     // The object has either been removed entirely from the repository,
diff --git a/crates/radicle-node/src/worker/upload_pack.rs b/crates/radicle-node/src/worker/upload_pack.rs
index 50de14ae..e84206ba 100644
--- a/crates/radicle-node/src/worker/upload_pack.rs
+++ b/crates/radicle-node/src/worker/upload_pack.rs
@@ -137,7 +137,7 @@ where
                         }
                     }
                     Err(e) => {
-                        log::error!(target: "worker", "Error on upload-pack channel read for {}: {e}", header.repo);
+                        log::debug!(target: "worker", "Failure on upload-pack channel read for {}: {e}", header.repo);
                         emitter.emit(events::UploadPack::error(header.repo, remote, e).into());
                         break;
                     }