diff --git a/Cargo.lock b/Cargo.lock
index 99dfbafafe28..50c2e8935832 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -16192,12 +16192,12 @@ dependencies = [
 name = "relay-utils"
 version = "0.1.0"
 dependencies = [
- "ansi_term",
  "anyhow",
  "async-std",
  "async-trait",
  "backoff",
  "bp-runtime",
+ "console",
  "env_logger 0.11.3",
  "futures",
  "isahc",
@@ -17668,7 +17668,7 @@ dependencies = [
 name = "sc-informant"
 version = "0.33.0"
 dependencies = [
- "ansi_term",
+ "console",
  "futures",
  "futures-timer",
  "log",
@@ -18364,8 +18364,8 @@ dependencies = [
 name = "sc-tracing"
 version = "28.0.0"
 dependencies = [
- "ansi_term",
  "chrono",
+ "console",
  "criterion",
  "is-terminal",
  "lazy_static",
diff --git a/Cargo.toml b/Cargo.toml
index 3886014dc2b4..e9ab2934f446 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -576,7 +576,6 @@ ahash = { version = "0.8.2" }
 alloy-primitives = { version = "0.4.2", default-features = false }
 alloy-sol-types = { version = "0.4.2", default-features = false }
 always-assert = { version = "0.1" }
-ansi_term = { version = "0.12.1" }
 anyhow = { version = "1.0.81" }
 aquamarine = { version = "0.5.0" }
 arbitrary = { version = "1.3.2" }
diff --git a/bridges/relays/utils/Cargo.toml b/bridges/relays/utils/Cargo.toml
index 93e42763967b..2c3f37750486 100644
--- a/bridges/relays/utils/Cargo.toml
+++ b/bridges/relays/utils/Cargo.toml
@@ -11,11 +11,11 @@ publish = false
 workspace = true
 
 [dependencies]
-ansi_term = { workspace = true }
 anyhow = { workspace = true }
 async-std = { workspace = true }
 async-trait = { workspace = true }
 backoff = { workspace = true }
+console = { workspace = true }
 isahc = { workspace = true }
 env_logger = { workspace = true }
 futures = { workspace = true }
diff --git a/bridges/relays/utils/src/initialize.rs b/bridges/relays/utils/src/initialize.rs
index 64d710242710..cd0377caa3d6 100644
--- a/bridges/relays/utils/src/initialize.rs
+++ b/bridges/relays/utils/src/initialize.rs
@@ -16,6 +16,7 @@
 
 //! Relayer initialization functions.
 
+use console::style;
 use parking_lot::Mutex;
 use std::{cell::RefCell, fmt::Display, io::Write};
 
@@ -55,7 +56,7 @@ pub fn initialize_logger(with_timestamp: bool) {
 			let timestamp = if cfg!(windows) {
 				Either::Left(timestamp)
 			} else {
-				Either::Right(ansi_term::Colour::Fixed(8).bold().paint(timestamp))
+				Either::Right(style(timestamp).black().bright().bold().to_string())
 			};
 
 			writeln!(
@@ -120,7 +121,7 @@ fn color_target(target: &str) -> impl Display + '_ {
 	if cfg!(windows) {
 		Either::Left(target)
 	} else {
-		Either::Right(ansi_term::Colour::Fixed(8).paint(target))
+		Either::Right(style(target).black().bright().to_string())
 	}
 }
 
@@ -129,13 +130,12 @@ fn color_level(level: log::Level) -> impl Display {
 		Either::Left(level)
 	} else {
 		let s = level.to_string();
-		use ansi_term::Colour as Color;
 		Either::Right(match level {
-			log::Level::Error => Color::Fixed(9).bold().paint(s),
-			log::Level::Warn => Color::Fixed(11).bold().paint(s),
-			log::Level::Info => Color::Fixed(10).paint(s),
-			log::Level::Debug => Color::Fixed(14).paint(s),
-			log::Level::Trace => Color::Fixed(12).paint(s),
+			log::Level::Error => style(s).red().bright().bold().to_string(),
+			log::Level::Warn => style(s).yellow().bright().bold().to_string(),
+			log::Level::Info => style(s).green().bright().to_string(),
+			log::Level::Debug => style(s).cyan().bright().to_string(),
+			log::Level::Trace => style(s).blue().bright().to_string(),
 		})
 	}
 }
diff --git a/cumulus/test/service/src/lib.rs b/cumulus/test/service/src/lib.rs
index 51cdebbaf54e..0458a0768925 100644
--- a/cumulus/test/service/src/lib.rs
+++ b/cumulus/test/service/src/lib.rs
@@ -891,7 +891,6 @@ pub fn node_config(
 		announce_block: true,
 		data_path: root,
 		base_path,
-		informant_output_format: Default::default(),
 		wasm_runtime_overrides: None,
 		runtime_cache_size: 2,
 	})
diff --git a/polkadot/node/test/service/src/lib.rs b/polkadot/node/test/service/src/lib.rs
index 35156a3a9372..a4e58253bb17 100644
--- a/polkadot/node/test/service/src/lib.rs
+++ b/polkadot/node/test/service/src/lib.rs
@@ -232,7 +232,6 @@ pub fn node_config(
 		announce_block: true,
 		data_path: root,
 		base_path,
-		informant_output_format: Default::default(),
 	}
 }
 
diff --git a/prdoc/pr_2923.prdoc b/prdoc/pr_2923.prdoc
new file mode 100644
index 000000000000..88bf1d48dd84
--- /dev/null
+++ b/prdoc/pr_2923.prdoc
@@ -0,0 +1,16 @@
+title: "Use `console` crate instead of `ansi_term`"
+
+doc:
+  - audience: Node Dev
+    description: |
+      This PR replace obsoleted `ansi_term` to `console`.
+
+crates:
+  - name: relay-utils
+    bump: patch
+  - name: sc-informant
+    bump: patch
+  - name: sc-tracing
+    bump: patch
+  - name: sc-service
+    bump: major
diff --git a/substrate/bin/node/cli/benches/block_production.rs b/substrate/bin/node/cli/benches/block_production.rs
index c16b25187e5f..8239637b3a9f 100644
--- a/substrate/bin/node/cli/benches/block_production.rs
+++ b/substrate/bin/node/cli/benches/block_production.rs
@@ -104,7 +104,6 @@ fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
 		announce_block: true,
 		data_path: base_path.path().into(),
 		base_path,
-		informant_output_format: Default::default(),
 		wasm_runtime_overrides: None,
 	};
 
diff --git a/substrate/bin/node/cli/benches/transaction_pool.rs b/substrate/bin/node/cli/benches/transaction_pool.rs
index 6618f4b1132e..9a71a4ec585d 100644
--- a/substrate/bin/node/cli/benches/transaction_pool.rs
+++ b/substrate/bin/node/cli/benches/transaction_pool.rs
@@ -99,7 +99,6 @@ fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
 		announce_block: true,
 		data_path: base_path.path().into(),
 		base_path,
-		informant_output_format: Default::default(),
 		wasm_runtime_overrides: None,
 	};
 
diff --git a/substrate/client/cli/src/config.rs b/substrate/client/cli/src/config.rs
index 783c9313121f..283148a6d6ad 100644
--- a/substrate/client/cli/src/config.rs
+++ b/substrate/client/cli/src/config.rs
@@ -27,7 +27,7 @@ use names::{Generator, Name};
 use sc_service::{
 	config::{
 		BasePath, Configuration, DatabaseSource, IpNetwork, KeystoreConfig, NetworkConfiguration,
-		NodeKeyConfig, OffchainWorkerConfig, OutputFormat, PrometheusConfig, PruningMode, Role,
+		NodeKeyConfig, OffchainWorkerConfig, PrometheusConfig, PruningMode, Role,
 		RpcBatchRequestConfig, RpcMethods, TelemetryEndpoints, TransactionPoolOptions,
 		WasmExecutionMethod,
 	},
@@ -550,7 +550,6 @@ pub trait CliConfiguration<DCV: DefaultConfigurationValues = ()>: Sized {
 			announce_block: self.announce_block()?,
 			role,
 			base_path,
-			informant_output_format: OutputFormat { enable_color: !self.disable_log_color()? },
 			runtime_cache_size,
 		})
 	}
diff --git a/substrate/client/cli/src/runner.rs b/substrate/client/cli/src/runner.rs
index 6d986e38d2fb..b0dbccfa634c 100644
--- a/substrate/client/cli/src/runner.rs
+++ b/substrate/client/cli/src/runner.rs
@@ -291,7 +291,6 @@ mod tests {
 				announce_block: true,
 				base_path: sc_service::BasePath::new(root.clone()),
 				data_path: root,
-				informant_output_format: Default::default(),
 				runtime_cache_size: 2,
 			},
 			runtime,
diff --git a/substrate/client/informant/Cargo.toml b/substrate/client/informant/Cargo.toml
index 9da2296deee3..aa54d9479f5c 100644
--- a/substrate/client/informant/Cargo.toml
+++ b/substrate/client/informant/Cargo.toml
@@ -16,7 +16,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-ansi_term = { workspace = true }
+console = { workspace = true }
 futures = { workspace = true }
 futures-timer = { workspace = true }
 log = { workspace = true, default-features = true }
diff --git a/substrate/client/informant/src/display.rs b/substrate/client/informant/src/display.rs
index cdbb83b6596c..655bf21c7115 100644
--- a/substrate/client/informant/src/display.rs
+++ b/substrate/client/informant/src/display.rs
@@ -16,8 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::OutputFormat;
-use ansi_term::Colour;
+use console::style;
 use log::info;
 use sc_client_api::ClientInfo;
 use sc_network::NetworkStatus;
@@ -47,19 +46,16 @@ pub struct InformantDisplay<B: BlockT> {
 	last_total_bytes_inbound: u64,
 	/// The last seen total of bytes sent.
 	last_total_bytes_outbound: u64,
-	/// The format to print output in.
-	format: OutputFormat,
 }
 
 impl<B: BlockT> InformantDisplay<B> {
 	/// Builds a new informant display system.
-	pub fn new(format: OutputFormat) -> InformantDisplay<B> {
+	pub fn new() -> InformantDisplay<B> {
 		InformantDisplay {
 			last_number: None,
 			last_update: Instant::now(),
 			last_total_bytes_inbound: 0,
 			last_total_bytes_outbound: 0,
-			format,
 		}
 	}
 
@@ -144,17 +140,17 @@ impl<B: BlockT> InformantDisplay<B> {
 
 		info!(
 			target: "substrate",
-			"{} {}{} ({} peers), best: #{} ({}), finalized #{} ({}), {} {}",
+			"{} {}{} ({} peers), best: #{} ({}), finalized #{} ({}), ⬇ {} ⬆ {}",
 			level,
-			self.format.print_with_color(Colour::White.bold(), status),
+			style(&status).white().bold(),
 			target,
-			self.format.print_with_color(Colour::White.bold(), num_connected_peers),
-			self.format.print_with_color(Colour::White.bold(), best_number),
+			style(num_connected_peers).white().bold(),
+			style(best_number).white().bold(),
 			best_hash,
-			self.format.print_with_color(Colour::White.bold(), finalized_number),
+			style(finalized_number).white().bold(),
 			info.chain.finalized_hash,
-			self.format.print_with_color(Colour::Green, format!("⬇ {}", TransferRateFormat(avg_bytes_per_sec_inbound))),
-			self.format.print_with_color(Colour::Red, format!("⬆ {}", TransferRateFormat(avg_bytes_per_sec_outbound))),
+			style(TransferRateFormat(avg_bytes_per_sec_inbound)).green(),
+			style(TransferRateFormat(avg_bytes_per_sec_outbound)).red(),
 		)
 	}
 }
diff --git a/substrate/client/informant/src/lib.rs b/substrate/client/informant/src/lib.rs
index af778529ffc5..d44364539a29 100644
--- a/substrate/client/informant/src/lib.rs
+++ b/substrate/client/informant/src/lib.rs
@@ -18,7 +18,7 @@
 
 //! Console informant. Prints sync progress and block events. Runs on the calling thread.
 
-use ansi_term::{Colour, Style};
+use console::style;
 use futures::prelude::*;
 use futures_timer::Delay;
 use log::{debug, info, trace};
@@ -36,71 +36,15 @@ fn interval(duration: Duration) -> impl Stream<Item = ()> + Unpin {
 	futures::stream::unfold((), move |_| Delay::new(duration).map(|_| Some(((), ())))).map(drop)
 }
 
-/// The format to print telemetry output in.
-#[derive(Clone, Debug)]
-pub struct OutputFormat {
-	/// Enable color output in logs.
-	///
-	/// Is enabled by default.
-	pub enable_color: bool,
-}
-
-impl Default for OutputFormat {
-	fn default() -> Self {
-		Self { enable_color: true }
-	}
-}
-
-enum ColorOrStyle {
-	Color(Colour),
-	Style(Style),
-}
-
-impl From<Colour> for ColorOrStyle {
-	fn from(value: Colour) -> Self {
-		Self::Color(value)
-	}
-}
-
-impl From<Style> for ColorOrStyle {
-	fn from(value: Style) -> Self {
-		Self::Style(value)
-	}
-}
-
-impl ColorOrStyle {
-	fn paint(&self, data: String) -> impl Display {
-		match self {
-			Self::Color(c) => c.paint(data),
-			Self::Style(s) => s.paint(data),
-		}
-	}
-}
-
-impl OutputFormat {
-	/// Print with color if `self.enable_color == true`.
-	fn print_with_color(
-		&self,
-		color: impl Into<ColorOrStyle>,
-		data: impl ToString,
-	) -> impl Display {
-		if self.enable_color {
-			color.into().paint(data.to_string()).to_string()
-		} else {
-			data.to_string()
-		}
-	}
-}
-
 /// Builds the informant and returns a `Future` that drives the informant.
-pub async fn build<B: BlockT, C, N, S>(client: Arc<C>, network: N, syncing: S, format: OutputFormat)
+pub async fn build<B: BlockT, C, N, S>(client: Arc<C>, network: N, syncing: S)
 where
 	N: NetworkStatusProvider,
 	S: SyncStatusProvider<B>,
 	C: UsageProvider<B> + HeaderMetadata<B> + BlockchainEvents<B>,
 	<C as HeaderMetadata<B>>::Error: Display,
 {
-	let mut display = display::InformantDisplay::new(format.clone());
+	let mut display = display::InformantDisplay::new();
 
 	let client_1 = client.clone();
 
@@ -130,14 +74,11 @@ where
 
 	futures::select! {
 		() = display_notifications.fuse() => (),
-		() = display_block_import(client, format).fuse() => (),
+		() = display_block_import(client).fuse() => (),
 	};
 }
 
-fn display_block_import<B: BlockT, C>(
-	client: Arc<C>,
-	format: OutputFormat,
-) -> impl Future<Output = ()>
+fn display_block_import<B: BlockT, C>(client: Arc<C>) -> impl Future<Output = ()>
 where
 	C: UsageProvider<B> + HeaderMetadata<B> + BlockchainEvents<B>,
 	<C as HeaderMetadata<B>>::Error: Display,
@@ -161,11 +102,11 @@ where
 				match maybe_ancestor {
 					Ok(ref ancestor) if ancestor.hash != *last_hash => info!(
 						"♻️  Reorg on #{},{} to #{},{}, common ancestor #{},{}",
-						format.print_with_color(Colour::Red.bold(), last_num),
+						style(last_num).red().bold(),
 						last_hash,
-						format.print_with_color(Colour::Green.bold(), n.header.number()),
+						style(n.header.number()).green().bold(),
 						n.hash,
-						format.print_with_color(Colour::White.bold(), ancestor.number),
+						style(ancestor.number).white().bold(),
 						ancestor.hash,
 					),
 					Ok(_) => {},
@@ -191,7 +132,7 @@ where
 			info!(
 				target: "substrate",
 				"{best_indicator} Imported #{} ({} → {})",
-				format.print_with_color(Colour::White.bold(), n.header.number()),
+				style(n.header.number()).white().bold(),
 				n.header.parent_hash(),
 				n.hash,
 			);
diff --git a/substrate/client/service/src/builder.rs b/substrate/client/service/src/builder.rs
index 06fc2ea3b304..638f30fad10e 100644
--- a/substrate/client/service/src/builder.rs
+++ b/substrate/client/service/src/builder.rs
@@ -514,12 +514,7 @@ where
 	spawn_handle.spawn(
 		"informant",
 		None,
-		sc_informant::build(
-			client.clone(),
-			network,
-			sync_service.clone(),
-			config.informant_output_format,
-		),
+		sc_informant::build(client.clone(), network, sync_service.clone()),
 	);
 
 	task_manager.keep_alive((config.base_path, rpc));
diff --git a/substrate/client/service/src/config.rs b/substrate/client/service/src/config.rs
index e4788f1f3376..f8d8511f2718 100644
--- a/substrate/client/service/src/config.rs
+++ b/substrate/client/service/src/config.rs
@@ -23,7 +23,6 @@ use prometheus_endpoint::Registry;
 use sc_chain_spec::ChainSpec;
 pub use sc_client_db::{BlocksPruning, Database, DatabaseSource, PruningMode};
 pub use sc_executor::{WasmExecutionMethod, WasmtimeInstantiationStrategy};
-pub use sc_informant::OutputFormat;
 pub use sc_network::{
 	config::{
 		MultiaddrWithPeerId, NetworkConfiguration, NodeKeyConfig, NonDefaultSetConfig, ProtocolId,
@@ -146,8 +145,6 @@ pub struct Configuration {
 	pub data_path: PathBuf,
 	/// Base path of the configuration. This is shared between chains.
 	pub base_path: BasePath,
-	/// Configuration of the output format that the informant uses.
-	pub informant_output_format: OutputFormat,
 	/// Maximum number of different runtime versions that can be cached.
 	pub runtime_cache_size: u8,
 }
diff --git a/substrate/client/service/test/src/lib.rs b/substrate/client/service/test/src/lib.rs
index e60bd9410c64..5b9bb537563d 100644
--- a/substrate/client/service/test/src/lib.rs
+++ b/substrate/client/service/test/src/lib.rs
@@ -264,7 +264,6 @@ fn node_config<E: ChainSpecExtension + Clone + 'static + Send + Sync>(
 		announce_block: true,
 		base_path: BasePath::new(root.clone()),
 		data_path: root,
-		informant_output_format: Default::default(),
 		runtime_cache_size: 2,
 	}
 }
diff --git a/substrate/client/tracing/Cargo.toml b/substrate/client/tracing/Cargo.toml
index cacb1351416a..f39c5ecb4e43 100644
--- a/substrate/client/tracing/Cargo.toml
+++ b/substrate/client/tracing/Cargo.toml
@@ -16,7 +16,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-ansi_term = { workspace = true }
+console = { workspace = true }
 is-terminal = { workspace = true }
 chrono = { workspace = true }
 codec = { workspace = true, default-features = true }
@@ -24,7 +24,6 @@ lazy_static = { workspace = true }
 libc = { workspace = true }
 log = { workspace = true, default-features = true }
 parking_lot = { workspace = true, default-features = true }
-regex = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, default-features = true }
 thiserror = { workspace = true }
@@ -42,6 +41,7 @@ sp-tracing = { workspace = true, default-features = true }
 
 [dev-dependencies]
 criterion = { workspace = true, default-features = true }
+regex = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["chrono", "parking_lot"] }
 
 [[bench]]
diff --git a/substrate/client/tracing/src/logging/event_format.rs b/substrate/client/tracing/src/logging/event_format.rs
index 8d875427841e..805b66d82fd5 100644
--- a/substrate/client/tracing/src/logging/event_format.rs
+++ b/substrate/client/tracing/src/logging/event_format.rs
@@ -17,9 +17,8 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::logging::fast_local_time::FastLocalTime;
-use ansi_term::Colour;
-use regex::Regex;
-use std::fmt::{self, Write};
+use console::style;
+use std::fmt;
 use tracing::{Event, Level, Subscriber};
 use tracing_log::NormalizeEvent;
 use tracing_subscriber::{
@@ -37,8 +36,6 @@ pub struct EventFormat<T = FastLocalTime> {
 	pub display_level: bool,
 	/// Sets whether or not the name of the current thread is displayed when formatting events.
 	pub display_thread_name: bool,
-	/// Enable ANSI terminal colors for formatted output.
-	pub enable_color: bool,
 	/// Duplicate INFO, WARN and ERROR messages to stdout.
 	pub dup_to_stdout: bool,
 }
@@ -53,20 +50,19 @@ where
 	pub(crate) fn format_event_custom<'b, 'w, S, N>(
 		&self,
 		ctx: &FmtContext<'b, S, N>,
-		writer: format::Writer<'w>,
+		mut writer: format::Writer<'w>,
 		event: &Event,
 	) -> fmt::Result
 	where
 		S: Subscriber + for<'a> LookupSpan<'a>,
 		N: for<'a> FormatFields<'a> + 'static,
 	{
-		let mut writer = &mut ControlCodeSanitizer::new(!self.enable_color, writer);
 		let normalized_meta = event.normalized_metadata();
 		let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
-		time::write(&self.timer, &mut format::Writer::new(&mut writer), self.enable_color)?;
+		time::write(&self.timer, &mut format::Writer::new(&mut writer))?;
 
 		if self.display_level {
-			let fmt_level = FmtLevel::new(meta.level(), self.enable_color);
+			let fmt_level = FmtLevel::new(meta.level());
 			write!(writer, "{} ", fmt_level)?;
 		}
 
@@ -74,17 +70,17 @@ where
 			let current_thread = std::thread::current();
 			match current_thread.name() {
 				Some(name) => {
-					write!(writer, "{} ", FmtThreadName::new(name))?;
+					write!(&mut writer, "{} ", FmtThreadName::new(name))?;
 				},
 				// fall-back to thread id when name is absent and ids are not enabled
 				None => {
-					write!(writer, "{:0>2?} ", current_thread.id())?;
+					write!(&mut writer, "{:0>2?} ", current_thread.id())?;
 				},
 			}
 		}
 
 		if self.display_target {
-			write!(writer, "{}: ", meta.target())?;
+			write!(&mut writer, "{}: ", meta.target())?;
 		}
 
 		// Custom code to display node name
@@ -92,24 +88,16 @@ where
 			for span in span.scope() {
 				let exts = span.extensions();
 				if let Some(prefix) = exts.get::<super::layers::Prefix>() {
-					write!(writer, "{}", prefix.as_str())?;
+					write!(&mut writer, "{}", prefix.as_str())?;
 					break
 				}
 			}
 		}
 
-		// The writer only sanitizes its output once it's flushed, so if we don't actually need
-		// to sanitize everything we need to flush out what was already buffered as-is and only
-		// force-sanitize what follows.
-		if !writer.sanitize {
-			writer.flush()?;
-			writer.sanitize = true;
-		}
-
-		ctx.format_fields(format::Writer::new(writer), event)?;
-		writeln!(writer)?;
+		ctx.format_fields(format::Writer::new(&mut writer), event)?;
+		writeln!(&mut writer)?;
 
-		writer.flush()
+		Ok(())
 	}
 }
 
@@ -147,12 +135,11 @@ where
 
 struct FmtLevel<'a> {
 	level: &'a Level,
-	ansi: bool,
 }
 
 impl<'a> FmtLevel<'a> {
-	pub(crate) fn new(level: &'a Level, ansi: bool) -> Self {
-		Self { level, ansi }
+	pub(crate) fn new(level: &'a Level) -> Self {
+		Self { level }
 	}
 }
 
@@ -164,22 +151,12 @@ const ERROR_STR: &str = "ERROR";
 
 impl<'a> fmt::Display for FmtLevel<'a> {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		if self.ansi {
-			match *self.level {
-				Level::TRACE => write!(f, "{}", Colour::Purple.paint(TRACE_STR)),
-				Level::DEBUG => write!(f, "{}", Colour::Blue.paint(DEBUG_STR)),
-				Level::INFO => write!(f, "{}", Colour::Green.paint(INFO_STR)),
-				Level::WARN => write!(f, "{}", Colour::Yellow.paint(WARN_STR)),
-				Level::ERROR => write!(f, "{}", Colour::Red.paint(ERROR_STR)),
-			}
-		} else {
-			match *self.level {
-				Level::TRACE => f.pad(TRACE_STR),
-				Level::DEBUG => f.pad(DEBUG_STR),
-				Level::INFO => f.pad(INFO_STR),
-				Level::WARN => f.pad(WARN_STR),
-				Level::ERROR => f.pad(ERROR_STR),
-			}
+		match *self.level {
+			Level::TRACE => write!(f, "{}", style(TRACE_STR).magenta()),
+			Level::DEBUG => write!(f, "{}", style(DEBUG_STR).blue()),
+			Level::INFO => write!(f, "{}", style(INFO_STR).green()),
+			Level::WARN => write!(f, "{}", style(WARN_STR).yellow()),
+			Level::ERROR => write!(f, "{}", style(ERROR_STR).red()),
 		}
 	}
 }
@@ -234,85 +211,22 @@ impl<'a> fmt::Display for FmtThreadName<'a> {
 //
 //       https://github.com/tokio-rs/tracing/blob/2f59b32/tracing-subscriber/src/fmt/time/mod.rs#L252
 mod time {
-	use ansi_term::Style;
 	use std::fmt;
 	use tracing_subscriber::fmt::{format, time::FormatTime};
 
-	pub(crate) fn write<T>(
-		timer: T,
-		writer: &mut format::Writer<'_>,
-		with_ansi: bool,
-	) -> fmt::Result
+	pub(crate) fn write<T>(timer: T, writer: &mut format::Writer<'_>) -> fmt::Result
 	where
 		T: FormatTime,
 	{
-		if with_ansi {
-			let style = Style::new().dimmed();
-			write!(writer, "{}", style.prefix())?;
+		if console::colors_enabled() {
+			write!(writer, "\x1B[2m")?;
 			timer.format_time(writer)?;
-			write!(writer, "{}", style.suffix())?;
+			write!(writer, "\x1B[0m")?;
 		} else {
 			timer.format_time(writer)?;
 		}
-		writer.write_char(' ')?;
-		Ok(())
-	}
-}
 
-/// A writer which (optionally) strips out terminal control codes from the logs.
-///
-/// This is used by [`EventFormat`] to sanitize the log messages.
-///
-/// It is required to call [`ControlCodeSanitizer::flush`] after all writes are done,
-/// because the content of these writes is buffered and will only be written to the
-/// `inner_writer` at that point.
-struct ControlCodeSanitizer<'a> {
-	sanitize: bool,
-	buffer: String,
-	inner_writer: format::Writer<'a>,
-}
-
-impl<'a> fmt::Write for ControlCodeSanitizer<'a> {
-	fn write_str(&mut self, buf: &str) -> fmt::Result {
-		self.buffer.push_str(buf);
-		Ok(())
-	}
-}
-
-// NOTE: When making any changes here make sure to also change this function in `sp-panic-handler`.
-fn strip_control_codes(input: &str) -> std::borrow::Cow<str> {
-	lazy_static::lazy_static! {
-		static ref RE: Regex = Regex::new(r#"(?x)
-			\x1b\[[^m]+m|        # VT100 escape codes
-			[
-			  \x00-\x09\x0B-\x1F # ASCII control codes / Unicode C0 control codes, except \n
-			  \x7F               # ASCII delete
-			  \u{80}-\u{9F}      # Unicode C1 control codes
-			  \u{202A}-\u{202E}  # Unicode left-to-right / right-to-left control characters
-			  \u{2066}-\u{2069}  # Same as above
-			]
-		"#).expect("regex parsing doesn't fail; qed");
-	}
-
-	RE.replace_all(input, "")
-}
-
-impl<'a> ControlCodeSanitizer<'a> {
-	/// Creates a new instance.
-	fn new(sanitize: bool, inner_writer: format::Writer<'a>) -> Self {
-		Self { sanitize, inner_writer, buffer: String::new() }
-	}
-
-	/// Write the buffered content to the `inner_writer`.
-	fn flush(&mut self) -> fmt::Result {
-		if self.sanitize {
-			let replaced = strip_control_codes(&self.buffer);
-			self.inner_writer.write_str(&replaced)?
-		} else {
-			self.inner_writer.write_str(&self.buffer)?
-		}
-
-		self.buffer.clear();
+		writer.write_char(' ')?;
 		Ok(())
 	}
 }
diff --git a/substrate/client/tracing/src/logging/mod.rs b/substrate/client/tracing/src/logging/mod.rs
index 05ec9fcf6ef0..74ce5f90ede9 100644
--- a/substrate/client/tracing/src/logging/mod.rs
+++ b/substrate/client/tracing/src/logging/mod.rs
@@ -182,12 +182,15 @@ where
 	let enable_color = force_colors.unwrap_or_else(|| io::stderr().is_terminal());
 	let timer = fast_local_time::FastLocalTime { with_fractional: detailed_output };
 
+	// We need to set both together, because we are may printing to `stdout` and `stderr`.
+	console::set_colors_enabled(enable_color);
+	console::set_colors_enabled_stderr(enable_color);
+
 	let event_format = EventFormat {
 		timer,
 		display_target: detailed_output,
 		display_level: detailed_output,
 		display_thread_name: detailed_output,
-		enable_color,
 		dup_to_stdout: !io::stderr().is_terminal() && io::stdout().is_terminal(),
 	};
 	let builder = FmtSubscriber::builder().with_env_filter(env_filter);
@@ -494,7 +497,7 @@ mod tests {
 	fn do_not_write_with_colors_on_tty_entrypoint() {
 		if env::var("ENABLE_LOGGING").is_ok() {
 			let _guard = init_logger("");
-			log::info!("{}", ansi_term::Colour::Yellow.paint(EXPECTED_LOG_MESSAGE));
+			log::info!("{}", console::style(EXPECTED_LOG_MESSAGE).yellow());
 		}
 	}
 
@@ -652,36 +655,4 @@ mod tests {
 			assert!(stderr.contains(&line));
 		}
 	}
-
-	#[test]
-	fn control_characters_are_always_stripped_out_from_the_log_messages() {
-		const RAW_LINE: &str = "$$START$$\x1B[1;32mIn\u{202a}\u{202e}\u{2066}\u{2069}ner\n\r\x7ftext!\u{80}\u{9f}\x1B[0m$$END$$";
-		const SANITIZED_LINE: &str = "$$START$$Inner\ntext!$$END$$";
-
-		let output = run_test_in_another_process(
-			"control_characters_are_always_stripped_out_from_the_log_messages",
-			|| {
-				std::env::set_var("RUST_LOG", "trace");
-				let mut builder = LoggerBuilder::new("");
-				builder.with_colors(true);
-				builder.init().unwrap();
-				log::error!("{}", RAW_LINE);
-			},
-		);
-
-		if let Some(output) = output {
-			let stderr = String::from_utf8(output.stderr).unwrap();
-			// The log messages should always be sanitized.
-			assert!(!stderr.contains(RAW_LINE));
-			assert!(stderr.contains(SANITIZED_LINE));
-
-			// The part where the timestamp, the logging level, etc. is printed out doesn't
-			// always have to be sanitized unless it's necessary, and here it shouldn't be.
-			assert!(stderr.contains("\x1B[31mERROR\x1B[0m"));
-
-			// Make sure the logs aren't being duplicated.
-			assert_eq!(stderr.find("ERROR"), stderr.rfind("ERROR"));
-			assert_eq!(stderr.find(SANITIZED_LINE), stderr.rfind(SANITIZED_LINE));
-		}
-	}
 }