diff --git a/nano/node/network.cpp b/nano/node/network.cpp
index 12ee9718d6..57c429c6b8 100644
--- a/nano/node/network.cpp
+++ b/nano/node/network.cpp
@@ -357,12 +357,12 @@ bool nano::network::merge_peer (nano::endpoint const & peer)
 	if (track_reachout (peer))
 	{
 		node.stats.inc (nano::stat::type::network, nano::stat::detail::merge_peer);
-		node.logger.debug (nano::log::type::network, "Initiating peer merge: {}", fmt::streamed (peer));
+		node.logger.debug (nano::log::type::network, "Initiating peer merge: {}", peer);
 		bool started = tcp_channels.start_tcp (peer);
 		if (!started)
 		{
 			node.stats.inc (nano::stat::type::tcp, nano::stat::detail::merge_peer_failed);
-			node.logger.debug (nano::log::type::network, "Peer merge failed: {}", fmt::streamed (peer));
+			node.logger.debug (nano::log::type::network, "Peer merge failed: {}", peer);
 		}
 		return started;
 	}
diff --git a/nano/node/online_reps.cpp b/nano/node/online_reps.cpp
index 1de0e27c2a..ea1494145d 100644
--- a/nano/node/online_reps.cpp
+++ b/nano/node/online_reps.cpp
@@ -32,7 +32,7 @@ void nano::online_reps::start ()
 		nano::lock_guard<nano::mutex> lock{ mutex };
 		cached_trended = trended_l;
 
-		logger.info (nano::log::type::online_reps, "Initial trended weight: {}", fmt::streamed (cached_trended));
+		logger.info (nano::log::type::online_reps, "Initial trended weight: {}", cached_trended);
 	}
 
 	thread = std::thread ([this] () {
@@ -125,7 +125,7 @@ void nano::online_reps::sample ()
 		nano::lock_guard<nano::mutex> lock{ mutex };
 		cached_trended = trended_l;
 	}
-	logger.info (nano::log::type::online_reps, "Updated trended weight: {}", fmt::streamed (trended_l));
+	logger.info (nano::log::type::online_reps, "Updated trended weight: {}", trended_l);
 }
 
 nano::uint128_t nano::online_reps::calculate_online () const
diff --git a/nano/node/peer_history.cpp b/nano/node/peer_history.cpp
index 0065a0057a..8307df3f61 100644
--- a/nano/node/peer_history.cpp
+++ b/nano/node/peer_history.cpp
@@ -92,7 +92,7 @@ void nano::peer_history::run_one ()
 		if (!exists)
 		{
 			stats.inc (nano::stat::type::peer_history, nano::stat::detail::inserted);
-			logger.debug (nano::log::type::peer_history, "Saved new peer: {}", fmt::streamed (endpoint));
+			logger.debug (nano::log::type::peer_history, "Saved new peer: {}", endpoint);
 		}
 		else
 		{
@@ -116,7 +116,7 @@ void nano::peer_history::run_one ()
 
 			stats.inc (nano::stat::type::peer_history, nano::stat::detail::erased);
 			logger.debug (nano::log::type::peer_history, "Erased peer: {} (not seen for {}s)",
-			fmt::streamed (endpoint.endpoint ()),
+			endpoint.endpoint (),
 			nano::log::seconds_delta (timestamp));
 		}
 	}
diff --git a/nano/node/transport/tcp_channels.cpp b/nano/node/transport/tcp_channels.cpp
index 62cc25b65b..9d2660a29f 100644
--- a/nano/node/transport/tcp_channels.cpp
+++ b/nano/node/transport/tcp_channels.cpp
@@ -56,7 +56,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint,
 	if (node.network.not_a_peer (nano::transport::map_tcp_to_endpoint (endpoint), node.config.allow_local_peers))
 	{
 		node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::not_a_peer);
-		node.logger.debug (nano::log::type::tcp_channels, "Rejected invalid endpoint channel: {}", fmt::streamed (endpoint));
+		node.logger.debug (nano::log::type::tcp_channels, "Rejected invalid endpoint channel: {}", endpoint);
 
 		return false; // Reject
 	}
@@ -76,7 +76,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint,
 	if (has_duplicate)
 	{
 		node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::channel_duplicate);
-		node.logger.debug (nano::log::type::tcp_channels, "Rejected duplicate channel: {} ({})", fmt::streamed (endpoint), node_id.to_node_id ());
+		node.logger.debug (nano::log::type::tcp_channels, "Rejected duplicate channel: {} ({})", endpoint, node_id.to_node_id ());
 
 		return false; // Reject
 	}
@@ -100,7 +100,7 @@ std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::cre
 	if (!check (endpoint, node_id))
 	{
 		node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_rejected);
-		node.logger.debug (nano::log::type::tcp_channels, "Rejected channel: {} ({})", fmt::streamed (endpoint), node_id.to_node_id ());
+		node.logger.debug (nano::log::type::tcp_channels, "Rejected channel: {} ({})", endpoint, node_id.to_node_id ());
 		// Rejection reason should be logged earlier
 
 		return nullptr;
@@ -108,7 +108,7 @@ std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::cre
 
 	node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_accepted);
 	node.logger.debug (nano::log::type::tcp_channels, "Accepted channel: {} ({}) ({})",
-	fmt::streamed (socket->remote_endpoint ()),
+	socket->remote_endpoint (),
 	to_string (socket->endpoint_type ()),
 	node_id.to_node_id ());
 
diff --git a/nano/node/transport/tcp_listener.cpp b/nano/node/transport/tcp_listener.cpp
index 34bc625a97..cf5d03c396 100644
--- a/nano/node/transport/tcp_listener.cpp
+++ b/nano/node/transport/tcp_listener.cpp
@@ -58,7 +58,7 @@ void nano::transport::tcp_listener::start ()
 			local = acceptor.local_endpoint ();
 		}
 
-		logger.debug (nano::log::type::tcp_listener, "Listening for incoming connections on: {}", fmt::streamed (acceptor.local_endpoint ()));
+		logger.debug (nano::log::type::tcp_listener, "Listening for incoming connections on: {}", acceptor.local_endpoint ());
 	}
 	catch (boost::system::system_error const & ex)
 	{
@@ -286,7 +286,7 @@ auto nano::transport::tcp_listener::connect_impl (asio::ip::tcp::endpoint endpoi
 		if (result.result == accept_result::accepted)
 		{
 			stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_success, nano::stat::dir::out);
-			logger.debug (nano::log::type::tcp_listener, "Successfully connected to: {}", fmt::streamed (endpoint));
+			logger.debug (nano::log::type::tcp_listener, "Successfully connected to: {}", endpoint);
 
 			release_assert (result.server);
 			result.server->initiate_handshake ();
@@ -300,7 +300,7 @@ auto nano::transport::tcp_listener::connect_impl (asio::ip::tcp::endpoint endpoi
 	catch (boost::system::system_error const & ex)
 	{
 		stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_error, nano::stat::dir::out);
-		logger.log (nano::log::level::debug, nano::log::type::tcp_listener, "Error connecting to: {} ({})", fmt::streamed (endpoint), ex.what ());
+		logger.log (nano::log::level::debug, nano::log::type::tcp_listener, "Error connecting to: {} ({})", endpoint, ex.what ());
 	}
 }
 
@@ -387,7 +387,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
 	if (auto result = check_limits (remote_endpoint.address (), type); result != accept_result::accepted)
 	{
 		stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_rejected, to_stat_dir (type));
-		logger.debug (nano::log::type::tcp_listener, "Rejected connection from: {} ({})", fmt::streamed (remote_endpoint), to_string (type));
+		logger.debug (nano::log::type::tcp_listener, "Rejected connection from: {} ({})", remote_endpoint, to_string (type));
 		// Rejection reason should be logged earlier
 
 		try
@@ -406,7 +406,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
 	}
 
 	stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_success, to_stat_dir (type));
-	logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", fmt::streamed (remote_endpoint), to_string (type));
+	logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", remote_endpoint, to_string (type));
 
 	auto socket = std::make_shared<nano::transport::tcp_socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type));
 	auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true);
diff --git a/nano/node/transport/tcp_server.cpp b/nano/node/transport/tcp_server.cpp
index 1097301cb8..251d76ce22 100644
--- a/nano/node/transport/tcp_server.cpp
+++ b/nano/node/transport/tcp_server.cpp
@@ -33,7 +33,7 @@ nano::transport::tcp_server::~tcp_server ()
 		return;
 	}
 
-	node->logger.debug (nano::log::type::tcp_server, "Exiting server: {}", fmt::streamed (remote_endpoint));
+	node->logger.debug (nano::log::type::tcp_server, "Exiting server: {}", remote_endpoint);
 
 	stop ();
 }
@@ -53,7 +53,7 @@ void nano::transport::tcp_server::start ()
 		return;
 	}
 
-	node->logger.debug (nano::log::type::tcp_server, "Starting server: {}", fmt::streamed (remote_endpoint));
+	node->logger.debug (nano::log::type::tcp_server, "Starting server: {}", remote_endpoint);
 
 	receive_message ();
 }
@@ -86,7 +86,7 @@ void nano::transport::tcp_server::receive_message ()
 			node->logger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})",
 			ec.message (),
 			to_string (this_l->message_deserializer->status),
-			fmt::streamed (this_l->remote_endpoint));
+			this_l->remote_endpoint);
 
 			this_l->stop ();
 		}
@@ -134,7 +134,7 @@ void nano::transport::tcp_server::received_message (std::unique_ptr<nano::messag
 			{
 				node->logger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})",
 				to_string (message_deserializer->status),
-				fmt::streamed (remote_endpoint));
+				remote_endpoint);
 			}
 			break;
 		}
@@ -193,7 +193,7 @@ auto nano::transport::tcp_server::process_message (std::unique_ptr<nano::message
 			case handshake_status::abort:
 			{
 				node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_abort);
-				node->logger.debug (nano::log::type::tcp_server, "Aborting handshake: {} ({})", to_string (message->type ()), fmt::streamed (remote_endpoint));
+				node->logger.debug (nano::log::type::tcp_server, "Aborting handshake: {} ({})", to_string (message->type ()), remote_endpoint);
 
 				return process_result::abort;
 			}
@@ -212,7 +212,7 @@ auto nano::transport::tcp_server::process_message (std::unique_ptr<nano::message
 				if (!success)
 				{
 					node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
-					node->logger.debug (nano::log::type::tcp_server, "Error switching to bootstrap mode: {} ({})", to_string (message->type ()), fmt::streamed (remote_endpoint));
+					node->logger.debug (nano::log::type::tcp_server, "Error switching to bootstrap mode: {} ({})", to_string (message->type ()), remote_endpoint);
 
 					return process_result::abort; // Switch failed, abort
 				}
@@ -276,21 +276,21 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
 	if (node->flags.disable_tcp_realtime)
 	{
 		node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
-		node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime mode ({})", fmt::streamed (remote_endpoint));
+		node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime mode ({})", remote_endpoint);
 
 		return handshake_status::abort;
 	}
 	if (!message.query && !message.response)
 	{
 		node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
-		node->logger.debug (nano::log::type::tcp_server, "Invalid handshake message received ({})", fmt::streamed (remote_endpoint));
+		node->logger.debug (nano::log::type::tcp_server, "Invalid handshake message received ({})", remote_endpoint);
 
 		return handshake_status::abort;
 	}
 	if (message.query && handshake_received) // Second handshake message should be a response only
 	{
 		node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
-		node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", fmt::streamed (remote_endpoint));
+		node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", remote_endpoint);
 
 		return handshake_status::abort;
 	}
@@ -300,7 +300,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
 	node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::node_id_handshake, nano::stat::dir::in);
 	node->logger.debug (nano::log::type::tcp_server, "Handshake message received: {} ({})",
 	message.query ? (message.response ? "query + response" : "query") : (message.response ? "response" : "none"),
-	fmt::streamed (remote_endpoint));
+	remote_endpoint);
 
 	if (message.query)
 	{
@@ -320,7 +320,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
 			else
 			{
 				node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
-				node->logger.debug (nano::log::type::tcp_server, "Error switching to realtime mode ({})", fmt::streamed (remote_endpoint));
+				node->logger.debug (nano::log::type::tcp_server, "Error switching to realtime mode ({})", remote_endpoint);
 
 				return handshake_status::abort;
 			}
@@ -328,7 +328,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
 		else
 		{
 			node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_response_invalid);
-			node->logger.debug (nano::log::type::tcp_server, "Invalid handshake response received ({})", fmt::streamed (remote_endpoint));
+			node->logger.debug (nano::log::type::tcp_server, "Invalid handshake response received ({})", remote_endpoint);
 
 			return handshake_status::abort;
 		}
@@ -348,7 +348,7 @@ void nano::transport::tcp_server::initiate_handshake ()
 	auto query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint));
 	nano::node_id_handshake message{ node->network_params.network, query };
 
-	node->logger.debug (nano::log::type::tcp_server, "Initiating handshake query ({})", fmt::streamed (remote_endpoint));
+	node->logger.debug (nano::log::type::tcp_server, "Initiating handshake query ({})", remote_endpoint);
 
 	auto shared_const_buffer = message.to_shared_const_buffer ();
 	socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) {
@@ -360,7 +360,7 @@ void nano::transport::tcp_server::initiate_handshake ()
 		if (ec)
 		{
 			node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error);
-			node->logger.debug (nano::log::type::tcp_server, "Error sending handshake query: {} ({})", ec.message (), fmt::streamed (this_l->remote_endpoint));
+			node->logger.debug (nano::log::type::tcp_server, "Error sending handshake query: {} ({})", ec.message (), this_l->remote_endpoint);
 
 			// Stop invalid handshake
 			this_l->stop ();
@@ -385,7 +385,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha
 	auto own_query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint));
 	nano::node_id_handshake handshake_response{ node->network_params.network, own_query, response };
 
-	node->logger.debug (nano::log::type::tcp_server, "Responding to handshake ({})", fmt::streamed (remote_endpoint));
+	node->logger.debug (nano::log::type::tcp_server, "Responding to handshake ({})", remote_endpoint);
 
 	auto shared_const_buffer = handshake_response.to_shared_const_buffer ();
 	socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) {
@@ -397,7 +397,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha
 		if (ec)
 		{
 			node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error);
-			node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), fmt::streamed (this_l->remote_endpoint));
+			node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), this_l->remote_endpoint);
 
 			// Stop invalid handshake
 			this_l->stop ();
@@ -551,7 +551,7 @@ void nano::transport::tcp_server::timeout ()
 	}
 	if (socket->has_timed_out ())
 	{
-		node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", fmt::streamed (remote_endpoint));
+		node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", remote_endpoint);
 
 		socket->close ();
 	}
@@ -600,7 +600,7 @@ bool nano::transport::tcp_server::to_bootstrap_connection ()
 
 	socket->type_set (nano::transport::socket_type::bootstrap);
 
-	node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", fmt::streamed (remote_endpoint));
+	node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", remote_endpoint);
 
 	return true;
 }
@@ -630,7 +630,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const &
 
 	socket->type_set (nano::transport::socket_type::realtime);
 
-	node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", fmt::streamed (remote_endpoint));
+	node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", remote_endpoint);
 
 	return true;
 }
diff --git a/nano/node/transport/tcp_socket.cpp b/nano/node/transport/tcp_socket.cpp
index 07bc9a4ec8..d5686c688a 100644
--- a/nano/node/transport/tcp_socket.cpp
+++ b/nano/node/transport/tcp_socket.cpp
@@ -83,10 +83,7 @@ void nano::transport::tcp_socket::async_connect (nano::tcp_endpoint const & endp
 					boost::system::error_code ec;
 					this_l->local = this_l->raw_socket.local_endpoint (ec);
 				}
-
-				node_l->logger.debug (nano::log::type::tcp_socket, "Successfully connected to: {}, local: {}",
-				fmt::streamed (this_l->remote),
-				fmt::streamed (this_l->local));
+				node_l->logger.debug (nano::log::type::tcp_socket, "Successfully connected to: {}, local: {}", this_l->remote, this_l->local);
 			}
 			callback (ec);
 		}));
@@ -318,7 +315,7 @@ void nano::transport::tcp_socket::ongoing_checkup ()
 		if (condition_to_disconnect)
 		{
 			// TODO: Stats
-			node_l->logger.debug (nano::log::type::tcp_socket, "Socket timeout, closing: {}", fmt::streamed (this_l->remote));
+			node_l->logger.debug (nano::log::type::tcp_socket, "Socket timeout, closing: {}", this_l->remote);
 			this_l->timed_out = true;
 			this_l->close ();
 		}
@@ -395,13 +392,13 @@ void nano::transport::tcp_socket::close_internal ()
 	{
 		node_l->stats.inc (nano::stat::type::socket, nano::stat::detail::error_socket_close);
 		node_l->logger.error (nano::log::type::tcp_socket, "Failed to close socket gracefully: {} ({})",
-		fmt::streamed (remote),
+		remote,
 		ec.message ());
 	}
 	else
 	{
 		// TODO: Stats
-		node_l->logger.debug (nano::log::type::tcp_socket, "Closed socket: {}", fmt::streamed (remote));
+		node_l->logger.debug (nano::log::type::tcp_socket, "Closed socket: {}", remote);
 	}
 }
 
diff --git a/nano/rpc/rpc.cpp b/nano/rpc/rpc.cpp
index a2c1e33202..fd90ea3e4f 100644
--- a/nano/rpc/rpc.cpp
+++ b/nano/rpc/rpc.cpp
@@ -45,7 +45,7 @@ void nano::rpc::start ()
 		logger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ());
 		throw std::runtime_error (ec.message ());
 	}
-	logger.info (nano::log::type::rpc, "RPC listening address: {}", fmt::streamed (acceptor.local_endpoint ()));
+	logger.info (nano::log::type::rpc, "RPC listening address: {}", acceptor.local_endpoint ());
 	acceptor.listen ();
 	accept ();
 }