diff --git a/bench/async_bench.cpp b/bench/async_bench.cpp
index df4dacfe..8844d4af 100644
--- a/bench/async_bench.cpp
+++ b/bench/async_bench.cpp
@@ -79,7 +79,7 @@ int main(int argc, char *argv[])
 
     try
     {
-        spdlog::set_formatter(make_unique<spdlog::pattern_formatter>("[%^%l%$] %v"));
+        spdlog::default_logger()->set_formatter(make_unique<spdlog::pattern_formatter>("[%^%l%$] %v"));
         if (argc == 1)
         {
             spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
diff --git a/bench/bench.cpp b/bench/bench.cpp
index 88ce46b2..5da91e32 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -44,32 +44,19 @@ void bench_threaded_logging(size_t threads, int iters)
 
     auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
     bench_mt(iters, std::move(basic_mt), threads);
-    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
-    basic_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(basic_mt_tracing), threads);
 
     spdlog::info("");
     auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
     bench_mt(iters, std::move(rotating_mt), threads);
-    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
-    rotating_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(rotating_mt_tracing), threads);
 
     spdlog::info("");
     auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
     bench_mt(iters, std::move(daily_mt), threads);
-    auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log");
-    daily_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(daily_mt_tracing), threads);
 
     spdlog::info("");
     auto empty_logger = std::make_shared<spdlog::logger>("level-off");
     empty_logger->set_level(spdlog::level::off);
     bench(iters, empty_logger);
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
 }
 
 void bench_single_threaded(int iters)
@@ -87,32 +74,20 @@ void bench_single_threaded(int iters)
     spdlog::info("");
     auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
     bench(iters, std::move(rotating_st));
-    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
-    rotating_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(rotating_st_tracing));
 
     spdlog::info("");
     auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
     bench(iters, std::move(daily_st));
-    auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log");
-    daily_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(daily_st_tracing));
 
     spdlog::info("");
     auto empty_logger = std::make_shared<spdlog::logger>("level-off");
     empty_logger->set_level(spdlog::level::off);
     bench(iters, empty_logger);
-
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
 }
 
 int main(int argc, char *argv[])
 {
     using spdlog::details::make_unique; // for pre c++14
-    spdlog::set_automatic_registration(false);
     spdlog::default_logger()->set_formatter(make_unique<spdlog::pattern_formatter>("[%^%l%$] %v"));
     int iters = 250000;
     size_t threads = 4;
@@ -162,7 +137,6 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 
     spdlog::info(
         fmt::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
-    spdlog::drop(log->name());
 }
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count)
@@ -193,7 +167,6 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_co
     auto delta_d = duration_cast<duration<double>>(delta).count();
     spdlog::info(
         fmt::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
-    spdlog::drop(log->name());
 }
 
 /*
diff --git a/bench/formatter-bench.cpp b/bench/formatter-bench.cpp
index dc9c7872..d55ee3f1 100644
--- a/bench/formatter-bench.cpp
+++ b/bench/formatter-bench.cpp
@@ -70,7 +70,7 @@ int main(int argc, char *argv[])
 {
 
     using spdlog::details::make_unique; // for pre c++14
-    spdlog::set_formatter(make_unique<spdlog::pattern_formatter>("[%^%l%$] %v"));
+    spdlog::default_logger()->set_formatter(make_unique<spdlog::pattern_formatter>("[%^%l%$] %v"));
     if (argc != 2)
     {
         spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
diff --git a/bench/latency.cpp b/bench/latency.cpp
index a0a4678e..b37c36d2 100644
--- a/bench/latency.cpp
+++ b/bench/latency.cpp
@@ -66,11 +66,9 @@ void bench_dev_null()
 {
     auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
     benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
-    spdlog::drop("/dev/null_st");
 
     auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
     benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
-    spdlog::drop("/dev/null_mt");
 }
 #endif // __linux__
 
@@ -90,19 +88,11 @@ int main(int argc, char *argv[])
     disabled_logger->set_level(spdlog::level::off);
     benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
     benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
-    // with backtrace of 64
-    auto tracing_disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    tracing_disabled_logger->enable_backtrace(64);
-    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
 
     auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
     benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
     benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
     benchmark::RegisterBenchmark("null_sink_fmt_string", bench_logger_fmt_string, null_logger_st);
-    // with backtrace of 64
-    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    tracing_null_logger_st->enable_backtrace(64);
-    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
 
 #ifdef __linux
     bench_dev_null();
@@ -113,30 +103,14 @@ int main(int argc, char *argv[])
         // basic_st
         auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
         benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
-        spdlog::drop("basic_st");
-        // with backtrace of 64
-        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
-        tracing_basic_st->enable_backtrace(64);
-        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
-        spdlog::drop("tracing_basic_st");
 
         // rotating st
         auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
         benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
-        spdlog::drop("rotating_st");
-        // with backtrace of 64
-        auto tracing_rotating_st =
-            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
-        spdlog::drop("tracing_rotating_st");
 
         // daily st
         auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
         benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
-        spdlog::drop("daily_st");
-        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
-        spdlog::drop("tracing_daily_st");
 
         //
         // Multi threaded bench, 10 loggers using same logger concurrently
@@ -147,17 +121,14 @@ int main(int argc, char *argv[])
         // basic_mt
         auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
         benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("basic_mt");
 
         // rotating mt
         auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
         benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("rotating_mt");
 
         // daily mt
         auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
         benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("daily_mt");
     }
 
     // async
@@ -167,11 +138,6 @@ int main(int argc, char *argv[])
         "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
     benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
 
-    auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
-        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-    async_logger_tracing->enable_backtrace(32);
-    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
-
     benchmark::Initialize(&argc, argv);
     benchmark::RunSpecifiedBenchmarks();
 }