diff --git a/.github/workflows/dev-builds.yaml b/.github/workflows/dev-builds.yaml
index 1e354b982f..dc1ec6600b 100644
--- a/.github/workflows/dev-builds.yaml
+++ b/.github/workflows/dev-builds.yaml
@@ -94,10 +94,10 @@ jobs:
     - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f
 
     - name: Build and package
-      run: TARGETS="x86_64-apple-darwin11" ./make.sh docker-release-git
+      run: TARGETS="x86_64-apple-darwin18" ./make.sh docker-release-git
 
-    - name: Publish artifact - x86_64-apple-darwin11
+    - name: Publish artifact - x86_64-apple-darwin18
       uses: actions/upload-artifact@e448a9b857ee2131e752b06002bf0e093c65e571
       with:
-        name: defichain-${{ env.BUILD_VERSION }}-x86_64-apple-darwin11
-        path: ./build/defichain-${{ env.BUILD_VERSION }}-x86_64-apple-darwin11.tar.gz
+        name: defichain-${{ env.BUILD_VERSION }}-x86_64-apple-darwin18
+        path: ./build/defichain-${{ env.BUILD_VERSION }}-x86_64-apple-darwin18.tar.gz
diff --git a/build-aux/m4/ax_boost_chrono.m4 b/build-aux/m4/ax_boost_chrono.m4
deleted file mode 100644
index 6ea77b9b3e..0000000000
--- a/build-aux/m4/ax_boost_chrono.m4
+++ /dev/null
@@ -1,118 +0,0 @@
-# ===========================================================================
-#     https://www.gnu.org/software/autoconf-archive/ax_boost_chrono.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_BOOST_CHRONO
-#
-# DESCRIPTION
-#
-#   Test for Chrono library from the Boost C++ libraries. The macro requires
-#   a preceding call to AX_BOOST_BASE. Further documentation is available at
-#   <http://randspringer.de/boost/index.html>.
-#
-#   This macro calls:
-#
-#     AC_SUBST(BOOST_CHRONO_LIB)
-#
-#   And sets:
-#
-#     HAVE_BOOST_CHRONO
-#
-# LICENSE
-#
-#   Copyright (c) 2012 Xiyue Deng <manphiz@gmail.com>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 4
-
-AC_DEFUN([AX_BOOST_CHRONO],
-[
-	AC_ARG_WITH([boost-chrono],
-	AS_HELP_STRING([--with-boost-chrono@<:@=special-lib@:>@],
-                   [use the Chrono library from boost - it is possible to specify a certain library for the linker
-                        e.g. --with-boost-chrono=boost_chrono-gcc-mt ]),
-        [
-        if test "$withval" = "no"; then
-			want_boost="no"
-        elif test "$withval" = "yes"; then
-            want_boost="yes"
-            ax_boost_user_chrono_lib=""
-        else
-		    want_boost="yes"
-		ax_boost_user_chrono_lib="$withval"
-		fi
-        ],
-        [want_boost="yes"]
-	)
-
-	if test "x$want_boost" = "xyes"; then
-        AC_REQUIRE([AC_PROG_CC])
-        AC_REQUIRE([AC_CANONICAL_BUILD])
-		CPPFLAGS_SAVED="$CPPFLAGS"
-		CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-		export CPPFLAGS
-
-		LDFLAGS_SAVED="$LDFLAGS"
-		LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
-		export LDFLAGS
-
-        AC_CACHE_CHECK(whether the Boost::Chrono library is available,
-					   ax_cv_boost_chrono,
-        [AC_LANG_PUSH([C++])
-			 CXXFLAGS_SAVE=$CXXFLAGS
-
-			 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <boost/chrono.hpp>]],
-                                   [[boost::chrono::system_clock::time_point* time = new boost::chrono::system_clock::time_point; delete time;]])],
-                   ax_cv_boost_chrono=yes, ax_cv_boost_chrono=no)
-			 CXXFLAGS=$CXXFLAGS_SAVE
-             AC_LANG_POP([C++])
-		])
-		if test "x$ax_cv_boost_chrono" = "xyes"; then
-			AC_SUBST(BOOST_CPPFLAGS)
-
-			AC_DEFINE(HAVE_BOOST_CHRONO,,[define if the Boost::Chrono library is available])
-            BOOSTLIBDIR=`echo $BOOST_LDFLAGS | sed -e 's/@<:@^\/@:>@*//'`
-
-			LDFLAGS_SAVE=$LDFLAGS
-            if test "x$ax_boost_user_chrono_lib" = "x"; then
-                for libextension in `ls $BOOSTLIBDIR/libboost_chrono*.so* $BOOSTLIBDIR/libboost_chrono*.dylib* $BOOSTLIBDIR/libboost_chrono*.a* 2>/dev/null | sed 's,.*/,,' | sed -e 's;^lib\(boost_chrono.*\)\.so.*$;\1;' -e 's;^lib\(boost_chrono.*\)\.dylib.*$;\1;' -e 's;^lib\(boost_chrono.*\)\.a.*$;\1;'` ; do
-                     ax_lib=${libextension}
-				    AC_CHECK_LIB($ax_lib, exit,
-                                 [BOOST_CHRONO_LIB="-l$ax_lib"; AC_SUBST(BOOST_CHRONO_LIB) link_chrono="yes"; break],
-                                 [link_chrono="no"])
-				done
-                if test "x$link_chrono" != "xyes"; then
-                for libextension in `ls $BOOSTLIBDIR/boost_chrono*.dll* $BOOSTLIBDIR/boost_chrono*.a* 2>/dev/null | sed 's,.*/,,' | sed -e 's;^\(boost_chrono.*\)\.dll.*$;\1;' -e 's;^\(boost_chrono.*\)\.a.*$;\1;'` ; do
-                     ax_lib=${libextension}
-				    AC_CHECK_LIB($ax_lib, exit,
-                                 [BOOST_CHRONO_LIB="-l$ax_lib"; AC_SUBST(BOOST_CHRONO_LIB) link_chrono="yes"; break],
-                                 [link_chrono="no"])
-				done
-                fi
-
-            else
-               for ax_lib in $ax_boost_user_chrono_lib boost_chrono-$ax_boost_user_chrono_lib; do
-				      AC_CHECK_LIB($ax_lib, exit,
-                                   [BOOST_CHRONO_LIB="-l$ax_lib"; AC_SUBST(BOOST_CHRONO_LIB) link_chrono="yes"; break],
-                                   [link_chrono="no"])
-                  done
-
-            fi
-            if test "x$ax_lib" = "x"; then
-                AC_MSG_ERROR(Could not find a version of the library!)
-            fi
-			if test "x$link_chrono" = "xno"; then
-				AC_MSG_ERROR(Could not link against $ax_lib !)
-			fi
-		fi
-
-		CPPFLAGS="$CPPFLAGS_SAVED"
-	LDFLAGS="$LDFLAGS_SAVED"
-	fi
-])
diff --git a/build-aux/m4/ax_boost_thread.m4 b/build-aux/m4/ax_boost_thread.m4
deleted file mode 100644
index 9f0bd0b23c..0000000000
--- a/build-aux/m4/ax_boost_thread.m4
+++ /dev/null
@@ -1,150 +0,0 @@
-# ===========================================================================
-#      http://www.gnu.org/software/autoconf-archive/ax_boost_thread.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_BOOST_THREAD
-#
-# DESCRIPTION
-#
-#   Test for Thread library from the Boost C++ libraries. The macro requires
-#   a preceding call to AX_BOOST_BASE. Further documentation is available at
-#   <http://randspringer.de/boost/index.html>.
-#
-#   This macro calls:
-#
-#     AC_SUBST(BOOST_THREAD_LIB)
-#
-#   And sets:
-#
-#     HAVE_BOOST_THREAD
-#
-# LICENSE
-#
-#   Copyright (c) 2009 Thomas Porschberg <thomas@randspringer.de>
-#   Copyright (c) 2009 Michael Tindal
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 27
-
-AC_DEFUN([AX_BOOST_THREAD],
-[
-	AC_ARG_WITH([boost-thread],
-	AS_HELP_STRING([--with-boost-thread@<:@=special-lib@:>@],
-                   [use the Thread library from boost - it is possible to specify a certain library for the linker
-                        e.g. --with-boost-thread=boost_thread-gcc-mt ]),
-        [
-        if test "$withval" = "no"; then
-			want_boost="no"
-        elif test "$withval" = "yes"; then
-            want_boost="yes"
-            ax_boost_user_thread_lib=""
-        else
-		    want_boost="yes"
-		ax_boost_user_thread_lib="$withval"
-		fi
-        ],
-        [want_boost="yes"]
-	)
-
-	if test "x$want_boost" = "xyes"; then
-        AC_REQUIRE([AC_PROG_CC])
-        AC_REQUIRE([AC_CANONICAL_BUILD])
-		CPPFLAGS_SAVED="$CPPFLAGS"
-		CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-		export CPPFLAGS
-
-		LDFLAGS_SAVED="$LDFLAGS"
-		LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
-		export LDFLAGS
-
-        AC_CACHE_CHECK(whether the Boost::Thread library is available,
-					   ax_cv_boost_thread,
-        [AC_LANG_PUSH([C++])
-			 CXXFLAGS_SAVE=$CXXFLAGS
-
-			 if test "x$host_os" = "xsolaris" ; then
-				 CXXFLAGS="-pthreads $CXXFLAGS"
-			 elif test "x$host_os" = "xmingw32" ; then
-				 CXXFLAGS="-mthreads $CXXFLAGS"
-			 else
-				CXXFLAGS="-pthread $CXXFLAGS"
-			 fi
-			 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <boost/thread/thread.hpp>]],
-                                   [[boost::thread_group thrds;
-                                   return 0;]])],
-                   ax_cv_boost_thread=yes, ax_cv_boost_thread=no)
-			 CXXFLAGS=$CXXFLAGS_SAVE
-             AC_LANG_POP([C++])
-		])
-		if test "x$ax_cv_boost_thread" = "xyes"; then
-           if test "x$host_os" = "xsolaris" ; then
-			  BOOST_CPPFLAGS="-pthreads $BOOST_CPPFLAGS"
-		   elif test "x$host_os" = "xmingw32" ; then
-			  BOOST_CPPFLAGS="-mthreads $BOOST_CPPFLAGS"
-		   else
-			  BOOST_CPPFLAGS="-pthread $BOOST_CPPFLAGS"
-		   fi
-
-			AC_SUBST(BOOST_CPPFLAGS)
-
-			AC_DEFINE(HAVE_BOOST_THREAD,,[define if the Boost::Thread library is available])
-            BOOSTLIBDIR=`echo $BOOST_LDFLAGS | sed -e 's/@<:@^\/@:>@*//'`
-
-			LDFLAGS_SAVE=$LDFLAGS
-                        case "x$host_os" in
-                          *bsd* )
-                               LDFLAGS="-pthread $LDFLAGS"
-                          break;
-                          ;;
-                        esac
-            if test "x$ax_boost_user_thread_lib" = "x"; then
-                ax_lib=
-                for libextension in `ls -r $BOOSTLIBDIR/libboost_thread* 2>/dev/null | sed 's,.*/lib,,' | sed 's,\..*,,'`; do
-                     ax_lib=${libextension}
-				    AC_CHECK_LIB($ax_lib, exit,
-                                 [BOOST_THREAD_LIB="-l$ax_lib"; AC_SUBST(BOOST_THREAD_LIB) link_thread="yes"; break],
-                                 [link_thread="no"])
-				done
-                if test "x$link_thread" != "xyes"; then
-                for libextension in `ls -r $BOOSTLIBDIR/boost_thread* 2>/dev/null | sed 's,.*/,,' | sed 's,\..*,,'`; do
-                     ax_lib=${libextension}
-				    AC_CHECK_LIB($ax_lib, exit,
-                                 [BOOST_THREAD_LIB="-l$ax_lib"; AC_SUBST(BOOST_THREAD_LIB) link_thread="yes"; break],
-                                 [link_thread="no"])
-				done
-                fi
-
-            else
-               for ax_lib in $ax_boost_user_thread_lib boost_thread-$ax_boost_user_thread_lib; do
-				      AC_CHECK_LIB($ax_lib, exit,
-                                   [BOOST_THREAD_LIB="-l$ax_lib"; AC_SUBST(BOOST_THREAD_LIB) link_thread="yes"; break],
-                                   [link_thread="no"])
-                  done
-
-            fi
-            if test "x$ax_lib" = "x"; then
-                AC_MSG_ERROR(Could not find a version of the boost_thread library!)
-            fi
-			if test "x$link_thread" = "xno"; then
-				AC_MSG_ERROR(Could not link against $ax_lib !)
-                        else
-                           case "x$host_os" in
-                              *bsd* )
-				BOOST_LDFLAGS="-pthread $BOOST_LDFLAGS"
-                              break;
-                              ;;
-                           esac
-
-			fi
-		fi
-
-		CPPFLAGS="$CPPFLAGS_SAVED"
-	LDFLAGS="$LDFLAGS_SAVED"
-	fi
-])
diff --git a/build-aux/m4/ax_cxx_compile_stdcxx.m4 b/build-aux/m4/ax_cxx_compile_stdcxx.m4
index f147cee3b1..f0a3badf59 100644
--- a/build-aux/m4/ax_cxx_compile_stdcxx.m4
+++ b/build-aux/m4/ax_cxx_compile_stdcxx.m4
@@ -45,9 +45,9 @@ dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
 dnl  (serial version number 13).
 
 AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
-  m4_if([$1], [11], [],
-        [$1], [14], [],
-        [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])],
+  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
+        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
+        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
         [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
   m4_if([$2], [], [],
         [$2], [ext], [],
@@ -57,26 +57,13 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
         [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
         [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
         [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
-  m4_if([$4], [], [ax_cxx_compile_cxx$1_try_default=true],
-        [$4], [default], [ax_cxx_compile_cxx$1_try_default=true],
-        [$4], [nodefault], [ax_cxx_compile_cxx$1_try_default=false],
-        [m4_fatal([invalid fourth argument `$4' to AX_CXX_COMPILE_STDCXX])])
   AC_LANG_PUSH([C++])dnl
   ac_success=no
 
-  m4_if([$4], [nodefault], [], [dnl
-  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
-  ax_cv_cxx_compile_cxx$1,
-  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-    [ax_cv_cxx_compile_cxx$1=yes],
-    [ax_cv_cxx_compile_cxx$1=no])])
-  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
-    ac_success=yes
-  fi])
-
   m4_if([$2], [noext], [], [dnl
   if test x$ac_success = xno; then
-    for switch in -std=gnu++$1 -std=gnu++0x; do
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
       cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
       AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
                      $cachevar,
@@ -102,22 +89,27 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
     dnl HP's aCC needs +std=c++11 according to:
     dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
     dnl Cray's crayCC needs "-h std=c++11"
-    for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
-                     $cachevar,
-        [ac_save_CXX="$CXX"
-         CXX="$CXX $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXX="$ac_save_CXX"])
-      if eval test x\$$cachevar = xyes; then
-        CXX="$CXX $switch"
-        if test -n "$CXXCPP" ; then
-          CXXCPP="$CXXCPP $switch"
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                       $cachevar,
+          [ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+            [eval $cachevar=yes],
+            [eval $cachevar=no])
+           CXX="$ac_save_CXX"])
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
         fi
-        ac_success=yes
+      done
+      if test x$ac_success = xyes; then
         break
       fi
     done
@@ -154,6 +146,11 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 )
 
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+)
 
 dnl  Tests for new features in C++11
 
@@ -191,11 +188,13 @@ namespace cxx11
 
     struct Base
     {
+      virtual ~Base() {}
       virtual void f() {}
     };
 
     struct Derived : public Base
     {
+      virtual ~Derived() override {}
       virtual void f() override {}
     };
 
@@ -524,7 +523,7 @@ namespace cxx14
 
   }
 
-  namespace test_digit_seperators
+  namespace test_digit_separators
   {
 
     constexpr auto ten_million = 100'000'000;
@@ -566,3 +565,287 @@ namespace cxx14
 #endif  // __cplusplus >= 201402L
 
 ]])
+
+
+dnl  Tests for new features in C++17
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
+// If the compiler admits that it is not ready for C++17, why torture it?
+// Hopefully, this will speed up the test.
+#ifndef __cplusplus
+#error "This is not a C++ compiler"
+#elif __cplusplus < 201703L
+#error "This is not a C++17 compiler"
+#else
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+namespace cxx17
+{
+  namespace test_constexpr_lambdas
+  {
+    constexpr int foo = [](){return 42;}();
+  }
+  namespace test::nested_namespace::definitions
+  {
+  }
+  namespace test_fold_expression
+  {
+    template<typename... Args>
+    int multiply(Args... args)
+    {
+      return (args * ... * 1);
+    }
+    template<typename... Args>
+    bool all(Args... args)
+    {
+      return (args && ...);
+    }
+  }
+  namespace test_extended_static_assert
+  {
+    static_assert (true);
+  }
+  namespace test_auto_brace_init_list
+  {
+    auto foo = {5};
+    auto bar {5};
+    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
+    static_assert(std::is_same<int, decltype(bar)>::value);
+  }
+  namespace test_typename_in_template_template_parameter
+  {
+    template<template<typename> typename X> struct D;
+  }
+  namespace test_fallthrough_nodiscard_maybe_unused_attributes
+  {
+    int f1()
+    {
+      return 42;
+    }
+    [[nodiscard]] int f2()
+    {
+      [[maybe_unused]] auto unused = f1();
+      switch (f1())
+      {
+      case 17:
+        f1();
+        [[fallthrough]];
+      case 42:
+        f1();
+      }
+      return f1();
+    }
+  }
+  namespace test_extended_aggregate_initialization
+  {
+    struct base1
+    {
+      int b1, b2 = 42;
+    };
+    struct base2
+    {
+      base2() {
+        b3 = 42;
+      }
+      int b3;
+    };
+    struct derived : base1, base2
+    {
+        int d;
+    };
+    derived d1 {{1, 2}, {}, 4};  // full initialization
+    derived d2 {{}, {}, 4};      // value-initialized bases
+  }
+  namespace test_general_range_based_for_loop
+  {
+    struct iter
+    {
+      int i;
+      int& operator* ()
+      {
+        return i;
+      }
+      const int& operator* () const
+      {
+        return i;
+      }
+      iter& operator++()
+      {
+        ++i;
+        return *this;
+      }
+    };
+    struct sentinel
+    {
+      int i;
+    };
+    bool operator== (const iter& i, const sentinel& s)
+    {
+      return i.i == s.i;
+    }
+    bool operator!= (const iter& i, const sentinel& s)
+    {
+      return !(i == s);
+    }
+    struct range
+    {
+      iter begin() const
+      {
+        return {0};
+      }
+      sentinel end() const
+      {
+        return {5};
+      }
+    };
+    void f()
+    {
+      range r {};
+      for (auto i : r)
+      {
+        [[maybe_unused]] auto v = i;
+      }
+    }
+  }
+  namespace test_lambda_capture_asterisk_this_by_value
+  {
+    struct t
+    {
+      int i;
+      int foo()
+      {
+        return [*this]()
+        {
+          return i;
+        }();
+      }
+    };
+  }
+  namespace test_enum_class_construction
+  {
+    enum class byte : unsigned char
+    {};
+    byte foo {42};
+  }
+  namespace test_constexpr_if
+  {
+    template <bool cond>
+    int f ()
+    {
+      if constexpr(cond)
+      {
+        return 13;
+      }
+      else
+      {
+        return 42;
+      }
+    }
+  }
+  namespace test_selection_statement_with_initializer
+  {
+    int f()
+    {
+      return 13;
+    }
+    int f2()
+    {
+      if (auto i = f(); i > 0)
+      {
+        return 3;
+      }
+      switch (auto i = f(); i + 4)
+      {
+      case 17:
+        return 2;
+      default:
+        return 1;
+      }
+    }
+  }
+  namespace test_template_argument_deduction_for_class_templates
+  {
+    template <typename T1, typename T2>
+    struct pair
+    {
+      pair (T1 p1, T2 p2)
+        : m1 {p1},
+          m2 {p2}
+      {}
+      T1 m1;
+      T2 m2;
+    };
+    void f()
+    {
+      [[maybe_unused]] auto p = pair{13, 42u};
+    }
+  }
+  namespace test_non_type_auto_template_parameters
+  {
+    template <auto n>
+    struct B
+    {};
+    B<5> b1;
+    B<'a'> b2;
+  }
+  namespace test_structured_bindings
+  {
+    int arr[2] = { 1, 2 };
+    std::pair<int, int> pr = { 1, 2 };
+    auto f1() -> int(&)[2]
+    {
+      return arr;
+    }
+    auto f2() -> std::pair<int, int>&
+    {
+      return pr;
+    }
+    struct S
+    {
+      int x1 : 2;
+      volatile double y1;
+    };
+    S f3()
+    {
+      return {};
+    }
+    auto [ x1, y1 ] = f1();
+    auto& [ xr1, yr1 ] = f1();
+    auto [ x2, y2 ] = f2();
+    auto& [ xr2, yr2 ] = f2();
+    const auto [ x3, y3 ] = f3();
+  }
+  namespace test_exception_spec_type_system
+  {
+    struct Good {};
+    struct Bad {};
+    void g1() noexcept;
+    void g2();
+    template<typename T>
+    Bad
+    f(T*, T*);
+    template<typename T1, typename T2>
+    Good
+    f(T1*, T2*);
+    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+  }
+  namespace test_inline_variables
+  {
+    template<class T> void f(T)
+    {}
+    template<class T> inline T g(T)
+    {
+      return T{};
+    }
+    template<> inline void f<>(int)
+    {}
+    template<> int g<>(int)
+    {
+      return 5;
+    }
+  }
+}  // namespace cxx17
+#endif  // __cplusplus < 201703L
+]])
+
diff --git a/build_msvc/defi_config.h b/build_msvc/defi_config.h
index 89f27811fd..02f91daed8 100644
--- a/build_msvc/defi_config.h
+++ b/build_msvc/defi_config.h
@@ -43,9 +43,6 @@
 /* define if the Boost library is available */
 #define HAVE_BOOST /**/
 
-/* define if the Boost::Chrono library is available */
-#define HAVE_BOOST_CHRONO /**/
-
 /* define if the Boost::Filesystem library is available */
 #define HAVE_BOOST_FILESYSTEM /**/
 
@@ -55,9 +52,6 @@
 /* define if the Boost::System library is available */
 #define HAVE_BOOST_SYSTEM /**/
 
-/* define if the Boost::Thread library is available */
-#define HAVE_BOOST_THREAD /**/
-
 /* define if the Boost::Unit_Test_Framework library is available */
 #define HAVE_BOOST_UNIT_TEST_FRAMEWORK /**/
 
@@ -330,12 +324,6 @@
 /* Define if the visibility attribute is supported. */
 #define HAVE_VISIBILITY_ATTRIBUTE 1
 
-/* Define this symbol if boost sleep works */
-/* #undef HAVE_WORKING_BOOST_SLEEP */
-
-/* Define this symbol if boost sleep_for works */
-#define HAVE_WORKING_BOOST_SLEEP_FOR 1
-
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #define LT_OBJDIR ".libs/"
 
diff --git a/ci/test/00_setup_env_amd64_asan.sh b/ci/test/00_setup_env_amd64_asan.sh
index 4aa3c630c3..a524e276d9 100644
--- a/ci/test/00_setup_env_amd64_asan.sh
+++ b/ci/test/00_setup_env_amd64_asan.sh
@@ -7,7 +7,7 @@
 export LC_ALL=C.UTF-8
 
 export HOST=x86_64-unknown-linux-gnu
-export PACKAGES="clang llvm python3-zmq qtbase5-dev qttools5-dev-tools libssl1.0-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev libdb5.3++-dev libminiupnpc-dev libzmq3-dev libprotobuf-dev protobuf-compiler libqrencode-dev"
+export PACKAGES="clang llvm python3-zmq qtbase5-dev qttools5-dev-tools libssl1.0-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-test-dev libdb5.3++-dev libminiupnpc-dev libzmq3-dev libprotobuf-dev protobuf-compiler libqrencode-dev"
 export NO_DEPENDS=1
 export GOAL="install"
 export DEFI_CONFIG="--enable-zmq --with-incompatible-bdb CPPFLAGS=-DDEBUG_LOCKORDER --with-sanitizers=address,integer,undefined CC=clang CXX=clang++"
diff --git a/ci/test/00_setup_env_amd64_fuzz.sh b/ci/test/00_setup_env_amd64_fuzz.sh
index bfc46ae7ce..33081a1ab4 100644
--- a/ci/test/00_setup_env_amd64_fuzz.sh
+++ b/ci/test/00_setup_env_amd64_fuzz.sh
@@ -7,7 +7,7 @@
 export LC_ALL=C.UTF-8
 
 export HOST=x86_64-unknown-linux-gnu
-export PACKAGES="clang llvm python3 libssl1.0-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev"
+export PACKAGES="clang llvm python3 libssl1.0-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-test-dev"
 export NO_DEPENDS=1
 export RUN_UNIT_TESTS=false
 export RUN_FUNCTIONAL_TESTS=false
diff --git a/ci/test/00_setup_env_amd64_trusty.sh b/ci/test/00_setup_env_amd64_trusty.sh
index 9b32c66a9a..9d37cdbf5c 100644
--- a/ci/test/00_setup_env_amd64_trusty.sh
+++ b/ci/test/00_setup_env_amd64_trusty.sh
@@ -8,7 +8,7 @@ export LC_ALL=C.UTF-8
 
 export HOST=x86_64-unknown-linux-gnu
 export DOCKER_NAME_TAG=ubuntu:14.04
-export PACKAGES="python3-zmq qtbase5-dev qttools5-dev-tools libicu-dev libpng-dev libssl-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev libdb5.1++-dev libzmq3-dev libprotobuf-dev protobuf-compiler libqrencode-dev"
+export PACKAGES="python3-zmq qtbase5-dev qttools5-dev-tools libicu-dev libpng-dev libssl-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-test-dev libdb5.1++-dev libzmq3-dev libprotobuf-dev protobuf-compiler libqrencode-dev"
 export NO_DEPENDS=1
 export RUN_FUNCTIONAL_TESTS=false
 export GOAL="install"
diff --git a/ci/test/00_setup_env_amd64_tsan.sh b/ci/test/00_setup_env_amd64_tsan.sh
index 6a5ef7b570..6dec401dd0 100644
--- a/ci/test/00_setup_env_amd64_tsan.sh
+++ b/ci/test/00_setup_env_amd64_tsan.sh
@@ -8,7 +8,7 @@ export LC_ALL=C.UTF-8
 
 export HOST=x86_64-unknown-linux-gnu
 export DOCKER_NAME_TAG=ubuntu:16.04
-export PACKAGES="clang llvm python3-zmq qtbase5-dev qttools5-dev-tools libssl-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev libdb5.3++-dev libminiupnpc-dev libzmq3-dev libprotobuf-dev protobuf-compiler libqrencode-dev"
+export PACKAGES="clang llvm python3-zmq qtbase5-dev qttools5-dev-tools libssl-dev libevent-dev bsdmainutils libboost-system-dev libboost-filesystem-dev libboost-test-dev libdb5.3++-dev libminiupnpc-dev libzmq3-dev libprotobuf-dev protobuf-compiler libqrencode-dev"
 export NO_DEPENDS=1
 export GOAL="install"
 export DEFI_CONFIG="--enable-zmq --disable-wallet CPPFLAGS=-DDEBUG_LOCKORDER --with-sanitizers=thread --disable-hardening --disable-asm CC=clang CXX=clang++"
diff --git a/ci/test/00_setup_env_mac.sh b/ci/test/00_setup_env_mac.sh
index 1da55be1dd..e6bfbd6169 100644
--- a/ci/test/00_setup_env_mac.sh
+++ b/ci/test/00_setup_env_mac.sh
@@ -6,9 +6,10 @@
 
 export LC_ALL=C.UTF-8
 
-export HOST=x86_64-apple-darwin14
+export HOST=x86_64-apple-darwin18
 export PACKAGES="cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python3-dev python3-setuptools"
-export OSX_SDK=10.11
+export XCODE_VERSION=11.3.1
+export XCODE_BUILD_ID=11C505
 export RUN_UNIT_TESTS=false
 export RUN_FUNCTIONAL_TESTS=false
 export GOAL="deploy"
diff --git a/ci/test/05_before_script.sh b/ci/test/05_before_script.sh
index 202b7ef3b7..7b97902919 100755
--- a/ci/test/05_before_script.sh
+++ b/ci/test/05_before_script.sh
@@ -10,11 +10,14 @@ DOCKER_EXEC echo \> \$HOME/.defi  # Make sure default datadir does not exist and
 
 mkdir -p depends/SDKs depends/sdk-sources
 
-if [ -n "$OSX_SDK" ] && [ ! -f depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz ]; then
-  curl --location --fail $SDK_URL/MacOSX${OSX_SDK}.sdk.tar.gz -o depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz
+OSX_SDK_BASENAME="Xcode-${XCODE_VERSION}-${XCODE_BUILD_ID}-extracted-SDK-with-libcxx-headers.tar.gz"
+OSX_SDK_PATH="${DEPENDS_DIR}/sdk-sources/${OSX_SDK_BASENAME}"
+
+if [ -n "$XCODE_VERSION" ] && [ ! -f "$OSX_SDK_PATH" ]; then
+  curl --location --fail "${SDK_URL}/${OSX_SDK_BASENAME}" -o "$OSX_SDK_PATH"
 fi
-if [ -n "$OSX_SDK" ] && [ -f depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz ]; then
-  tar -C depends/SDKs -xf depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz
+if [ -n "$XCODE_VERSION" ] && [ -f "$OSX_SDK_PATH" ]; then
+  DOCKER_EXEC tar -C "${DEPENDS_DIR}/SDKs" -xf "$OSX_SDK_PATH"
 fi
 if [[ $HOST = *-mingw32 ]]; then
   DOCKER_EXEC update-alternatives --set $HOST-g++ \$\(which $HOST-g++-posix\)
diff --git a/configure.ac b/configure.ac
index fd6027de8a..89e8249078 100644
--- a/configure.ac
+++ b/configure.ac
@@ -61,8 +61,10 @@ case $host in
      lt_cv_deplibs_check_method="pass_all"
   ;;
 esac
-dnl Require C++11 compiler (no GNU extensions)
-AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory], [nodefault])
+
+dnl Require C++17 compiler (no GNU extensions)
+AX_CXX_COMPILE_STDCXX([17], [noext], [mandatory])
+
 dnl Check if -latomic is required for <std::atomic>
 CHECK_ATOMIC
 
@@ -495,7 +497,7 @@ case $host in
        AC_MSG_ERROR("windres not found")
      fi
 
-     CPPFLAGS="$CPPFLAGS -D_MT -DWIN32 -D_WINDOWS -DBOOST_THREAD_USE_LIB -D_WIN32_WINNT=0x0601"
+     CPPFLAGS="$CPPFLAGS -D_MT -DWIN32 -D_WINDOWS -D_WIN32_WINNT=0x0601"
      LEVELDB_TARGET_FLAGS="-DOS_WINDOWS"
      if test "x$CXXFLAGS_overridden" = "xno"; then
        CXXFLAGS="$CXXFLAGS -w"
@@ -997,8 +999,6 @@ if test x$want_boost = xno; then
 fi
 AX_BOOST_SYSTEM
 AX_BOOST_FILESYSTEM
-AX_BOOST_THREAD
-AX_BOOST_CHRONO
 
 dnl Boost 1.56 through 1.62 allow using std::atomic instead of its own atomic
 dnl counter implementations. In 1.63 and later the std::atomic approach is default.
@@ -1065,7 +1065,7 @@ fi
 
 if test x$use_boost = xyes; then
 
-BOOST_LIBS="$BOOST_LDFLAGS $BOOST_SYSTEM_LIB $BOOST_FILESYSTEM_LIB $BOOST_THREAD_LIB $BOOST_CHRONO_LIB"
+BOOST_LIBS="$BOOST_LDFLAGS $BOOST_SYSTEM_LIB $BOOST_FILESYSTEM_LIB"
 
 
 dnl If boost (prior to 1.57) was built without c++11, it emulated scoped enums
@@ -1103,57 +1103,6 @@ AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 LIBS="$TEMP_LIBS"
 CPPFLAGS="$TEMP_CPPFLAGS"
 
-dnl Boost >= 1.50 uses sleep_for rather than the now-deprecated sleep, however
-dnl it was broken from 1.50 to 1.52 when backed by nanosleep. Use sleep_for if
-dnl a working version is available, else fall back to sleep. sleep was removed
-dnl after 1.56.
-dnl If neither is available, abort.
-TEMP_LIBS="$LIBS"
-LIBS="$BOOST_LIBS $LIBS"
-TEMP_CPPFLAGS="$CPPFLAGS"
-CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-  #include <boost/thread/thread.hpp>
-  #include <boost/version.hpp>
-  ]],[[
-  #if BOOST_VERSION >= 105000 && (!defined(BOOST_HAS_NANOSLEEP) || BOOST_VERSION >= 105200)
-      boost::this_thread::sleep_for(boost::chrono::milliseconds(0));
-  #else
-   choke me
-  #endif
-  ]])],
-  [boost_sleep=yes;
-     AC_DEFINE(HAVE_WORKING_BOOST_SLEEP_FOR, 1, [Define this symbol if boost sleep_for works])],
-  [boost_sleep=no])
-LIBS="$TEMP_LIBS"
-CPPFLAGS="$TEMP_CPPFLAGS"
-
-if test x$boost_sleep != xyes; then
-TEMP_LIBS="$LIBS"
-LIBS="$BOOST_LIBS $LIBS"
-TEMP_CPPFLAGS="$CPPFLAGS"
-CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-  #include <boost/version.hpp>
-  #include <boost/thread.hpp>
-  #include <boost/date_time/posix_time/posix_time_types.hpp>
-  ]],[[
-  #if BOOST_VERSION <= 105600
-      boost::this_thread::sleep(boost::posix_time::milliseconds(0));
-  #else
-   choke me
-  #endif
-  ]])],
-  [boost_sleep=yes; AC_DEFINE(HAVE_WORKING_BOOST_SLEEP, 1, [Define this symbol if boost sleep works])],
-  [boost_sleep=no])
-LIBS="$TEMP_LIBS"
-CPPFLAGS="$TEMP_CPPFLAGS"
-fi
-
-if test x$boost_sleep != xyes; then
-  AC_MSG_ERROR(No working boost sleep implementation found.)
-fi
-
 fi
 
 if test x$use_pkgconfig = xyes; then
diff --git a/contrib/dockerfiles/x86_64-apple-darwin11.dockerfile b/contrib/dockerfiles/x86_64-apple-darwin18.dockerfile
similarity index 98%
rename from contrib/dockerfiles/x86_64-apple-darwin11.dockerfile
rename to contrib/dockerfiles/x86_64-apple-darwin18.dockerfile
index c42737cae4..10c17fab2a 100644
--- a/contrib/dockerfiles/x86_64-apple-darwin11.dockerfile
+++ b/contrib/dockerfiles/x86_64-apple-darwin18.dockerfile
@@ -1,4 +1,4 @@
-ARG TARGET=x86_64-apple-darwin11
+ARG TARGET=x86_64-apple-darwin18
 
 # -----------
 FROM ubuntu:18.04 as builder-base
diff --git a/depends/README.md b/depends/README.md
index 69bc2a0222..e18ba57967 100644
--- a/depends/README.md
+++ b/depends/README.md
@@ -25,7 +25,7 @@ Common `host-platform-triplets` for cross compilation are:
 - `i686-pc-linux-gnu` for Linux 32 bit
 - `x86_64-pc-linux-gnu` for x86 Linux
 - `x86_64-w64-mingw32` for Win64
-- `x86_64-apple-darwin14` for macOS
+- `x86_64-apple-darwin18` for macOS
 - `arm-linux-gnueabihf` for Linux ARM 32 bit
 - `aarch64-linux-gnu` for Linux ARM 64 bit
 - `riscv32-linux-gnu` for Linux RISC-V 32 bit
diff --git a/depends/hosts/darwin.mk b/depends/hosts/darwin.mk
index a1c943d60b..b14ce09cb8 100644
--- a/depends/hosts/darwin.mk
+++ b/depends/hosts/darwin.mk
@@ -1,7 +1,10 @@
-OSX_MIN_VERSION=10.10
-OSX_SDK_VERSION=10.11
-OSX_SDK=$(SDK_PATH)/MacOSX$(OSX_SDK_VERSION).sdk
-LD64_VERSION=253.9
+OSX_MIN_VERSION=10.14
+OSX_SDK_VERSION=10.15.1
+XCODE_VERSION=11.3.1
+XCODE_BUILD_ID=11C505
+OSX_SDK=$(SDK_PATH)/Xcode-$(XCODE_VERSION)-$(XCODE_BUILD_ID)-extracted-SDK-with-libcxx-headers
+LD64_VERSION=530
+
 darwin_CC=clang -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -mlinker-version=$(LD64_VERSION)
 darwin_CXX=clang++ -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -mlinker-version=$(LD64_VERSION) -stdlib=libc++
 
diff --git a/depends/packages/bdb.mk b/depends/packages/bdb.mk
index 6cdb79592b..f983c754ab 100644
--- a/depends/packages/bdb.mk
+++ b/depends/packages/bdb.mk
@@ -9,7 +9,7 @@ define $(package)_set_vars
 $(package)_config_opts=--disable-shared --enable-cxx --disable-replication
 $(package)_config_opts_mingw32=--enable-mingw
 $(package)_config_opts_linux=--with-pic
-$(package)_cxxflags=-std=c++11
+$(package)_cxxflags=-std=c++17
 $(package)_cppflags_mingw32=-DUNICODE -D_UNICODE
 endef
 
diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk
index c84c5d0ab1..3188720254 100644
--- a/depends/packages/boost.mk
+++ b/depends/packages/boost.mk
@@ -19,8 +19,8 @@ $(package)_toolset_$(host_os)=gcc
 $(package)_archiver_$(host_os)=$($(package)_ar)
 $(package)_toolset_darwin=darwin
 $(package)_archiver_darwin=$($(package)_libtool)
-$(package)_config_libraries=chrono,filesystem,system,thread,test
-$(package)_cxxflags=-std=c++11 -fvisibility=hidden
+$(package)_config_libraries=filesystem,system,test
+$(package)_cxxflags=-std=c++17 -fvisibility=hidden
 $(package)_cxxflags_linux=-fPIC
 endef
 
diff --git a/depends/packages/native_cctools.mk b/depends/packages/native_cctools.mk
index a065256c1c..74c32c4e38 100644
--- a/depends/packages/native_cctools.mk
+++ b/depends/packages/native_cctools.mk
@@ -1,45 +1,55 @@
 package=native_cctools
-$(package)_version=807d6fd1be5d2224872e381870c0a75387fe05e6
-$(package)_download_path=https://github.com/theuni/cctools-port/archive
+$(package)_version=4da2f3b485bcf4cef526f30c0b8c0bcda99cdbb4
+$(package)_download_path=https://github.com/tpoechtrager/cctools-port/archive
 $(package)_file_name=$($(package)_version).tar.gz
-$(package)_sha256_hash=a09c9ba4684670a0375e42d9d67e7f12c1f62581a27f28f7c825d6d7032ccc6a
+$(package)_sha256_hash=a2d491c0981cef72fee2b833598f20f42a6c44a7614a61c439bda93d56446fec
 $(package)_build_subdir=cctools
-$(package)_clang_version=3.7.1
-$(package)_clang_download_path=https://llvm.org/releases/$($(package)_clang_version)
+$(package)_clang_version=8.0.0
+$(package)_clang_download_path=https://releases.llvm.org/$($(package)_clang_version)
 $(package)_clang_download_file=clang+llvm-$($(package)_clang_version)-x86_64-linux-gnu-ubuntu-14.04.tar.xz
 $(package)_clang_file_name=clang-llvm-$($(package)_clang_version)-x86_64-linux-gnu-ubuntu-14.04.tar.xz
-$(package)_clang_sha256_hash=99b28a6b48e793705228a390471991386daa33a9717cd9ca007fcdde69608fd9
+$(package)_clang_sha256_hash=9ef854b71949f825362a119bf2597f744836cb571131ae6b721cd102ffea8cd0
+
+$(package)_libtapi_version=3efb201881e7a76a21e0554906cf306432539cef
+$(package)_libtapi_download_path=https://github.com/tpoechtrager/apple-libtapi/archive
+$(package)_libtapi_download_file=$($(package)_libtapi_version).tar.gz
+$(package)_libtapi_file_name=$($(package)_libtapi_version).tar.gz
+$(package)_libtapi_sha256_hash=380c1ca37cfa04a8699d0887a8d3ee1ad27f3d08baba78887c73b09485c0fbd3
+
 $(package)_extra_sources=$($(package)_clang_file_name)
+$(package)_extra_sources += $($(package)_libtapi_file_name)
 
 define $(package)_fetch_cmds
 $(call fetch_file,$(package),$($(package)_download_path),$($(package)_download_file),$($(package)_file_name),$($(package)_sha256_hash)) && \
-$(call fetch_file,$(package),$($(package)_clang_download_path),$($(package)_clang_download_file),$($(package)_clang_file_name),$($(package)_clang_sha256_hash))
+$(call fetch_file,$(package),$($(package)_clang_download_path),$($(package)_clang_download_file),$($(package)_clang_file_name),$($(package)_clang_sha256_hash)) && \
+$(call fetch_file,$(package),$($(package)_libtapi_download_path),$($(package)_libtapi_download_file),$($(package)_libtapi_file_name),$($(package)_libtapi_sha256_hash))
 endef
 
 define $(package)_extract_cmds
   mkdir -p $($(package)_extract_dir) && \
   echo "$($(package)_sha256_hash)  $($(package)_source)" > $($(package)_extract_dir)/.$($(package)_file_name).hash && \
   echo "$($(package)_clang_sha256_hash)  $($(package)_source_dir)/$($(package)_clang_file_name)" >> $($(package)_extract_dir)/.$($(package)_file_name).hash && \
+  echo "$($(package)_libtapi_sha256_hash)  $($(package)_source_dir)/$($(package)_libtapi_file_name)" >> $($(package)_extract_dir)/.$($(package)_file_name).hash && \
   $(build_SHA256SUM) -c $($(package)_extract_dir)/.$($(package)_file_name).hash && \
-  mkdir -p toolchain/bin toolchain/lib/clang/3.5/include && \
+  mkdir -p toolchain/bin toolchain/lib/clang/$($(package)_clang_version)/include && \
+  mkdir -p libtapi && \
+  tar --no-same-owner --strip-components=1 -C libtapi -xf $($(package)_source_dir)/$($(package)_libtapi_file_name) && \
   tar --no-same-owner --strip-components=1 -C toolchain -xf $($(package)_source_dir)/$($(package)_clang_file_name) && \
   rm -f toolchain/lib/libc++abi.so* && \
-  echo "#!/bin/sh" > toolchain/bin/$(host)-dsymutil && \
-  echo "exit 0" >> toolchain/bin/$(host)-dsymutil && \
-  chmod +x toolchain/bin/$(host)-dsymutil && \
   tar --no-same-owner --strip-components=1 -xf $($(package)_source)
 endef
 
 define $(package)_set_vars
-$(package)_config_opts=--target=$(host) --disable-lto-support
-$(package)_ldflags+=-Wl,-rpath=\\$$$$$$$$\$$$$$$$$ORIGIN/../lib
-$(package)_cc=$($(package)_extract_dir)/toolchain/bin/clang
-$(package)_cxx=$($(package)_extract_dir)/toolchain/bin/clang++
+  $(package)_config_opts=--target=$(host) --disable-lto-support --with-libtapi=$($(package)_extract_dir)
+  $(package)_ldflags+=-Wl,-rpath=\\$$$$$$$$\$$$$$$$$ORIGIN/../lib
+  $(package)_cc=$($(package)_extract_dir)/toolchain/bin/clang
+  $(package)_cxx=$($(package)_extract_dir)/toolchain/bin/clang++
 endef
 
 define $(package)_preprocess_cmds
-  cd $($(package)_build_subdir); ./autogen.sh && \
-  sed -i.old "/define HAVE_PTHREADS/d" ld64/src/ld/InputFiles.h
+  CC=$($(package)_cc) CXX=$($(package)_cxx) INSTALLPREFIX=$($(package)_extract_dir) ./libtapi/build.sh && \
+  CC=$($(package)_cc) CXX=$($(package)_cxx) INSTALLPREFIX=$($(package)_extract_dir) ./libtapi/install.sh && \
+  sed -i.old "/define HAVE_PTHREADS/d" $($(package)_build_subdir)/ld64/src/ld/InputFiles.h
 endef
 
 define $(package)_config_cmds
@@ -52,6 +62,9 @@ endef
 
 define $(package)_stage_cmds
   $(MAKE) DESTDIR=$($(package)_staging_dir) install && \
+  mkdir -p $($(package)_staging_prefix_dir)/lib/ && \
+  cd $($(package)_extract_dir) && \
+  cp lib/libtapi.so.6 $($(package)_staging_prefix_dir)/lib/ && \
   cd $($(package)_extract_dir)/toolchain && \
   mkdir -p $($(package)_staging_prefix_dir)/lib/clang/$($(package)_clang_version)/include && \
   mkdir -p $($(package)_staging_prefix_dir)/bin $($(package)_staging_prefix_dir)/include && \
@@ -59,7 +72,6 @@ define $(package)_stage_cmds
   cp -P bin/clang++ $($(package)_staging_prefix_dir)/bin/ &&\
   cp lib/libLTO.so $($(package)_staging_prefix_dir)/lib/ && \
   cp -rf lib/clang/$($(package)_clang_version)/include/* $($(package)_staging_prefix_dir)/lib/clang/$($(package)_clang_version)/include/ && \
-  cp bin/llvm-dsymutil $($(package)_staging_prefix_dir)/bin/$(host)-dsymutil && \
-  if `test -d include/c++/`; then cp -rf include/c++/ $($(package)_staging_prefix_dir)/include/; fi && \
-  if `test -d lib/c++/`; then cp -rf lib/c++/ $($(package)_staging_prefix_dir)/lib/; fi
+  cp bin/dsymutil $($(package)_staging_prefix_dir)/bin/$(host)-dsymutil
 endef
+
diff --git a/depends/packages/zeromq.mk b/depends/packages/zeromq.mk
index 9ac037ebb5..f9b26a1bf3 100644
--- a/depends/packages/zeromq.mk
+++ b/depends/packages/zeromq.mk
@@ -10,7 +10,7 @@ define $(package)_set_vars
   $(package)_config_opts += --without-libsodium --without-libgssapi_krb5 --without-pgm --without-norm --without-vmci
   $(package)_config_opts += --disable-libunwind --disable-radix-tree --without-gcov
   $(package)_config_opts_linux=--with-pic
-  $(package)_cxxflags=-std=c++11
+  $(package)_cxxflags=-std=c++17
 endef
 
 define $(package)_preprocess_cmds
diff --git a/doc/build-unix.md b/doc/build-unix.md
index aaf3a24683..fb8ee8e599 100644
--- a/doc/build-unix.md
+++ b/doc/build-unix.md
@@ -81,7 +81,7 @@ Build requirements:
 
 Now, you can either build from self-compiled [depends](/depends/README.md) or install the required dependencies:
 
-    sudo apt-get install libssl-dev libevent-dev libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev
+    sudo apt-get install libssl-dev libevent-dev libboost-system-dev libboost-filesystem-dev libboost-test-dev
 
 BerkeleyDB is required for the wallet.
 
diff --git a/doc/dependencies.md b/doc/dependencies.md
index 70bc5e6ed3..e0f13c9a59 100644
--- a/doc/dependencies.md
+++ b/doc/dependencies.md
@@ -7,11 +7,11 @@ These are the dependencies currently used by Bitcoin Core. You can find instruct
 | --- | --- | --- | --- | --- | --- |
 | Berkeley DB | [4.8.30](https://www.oracle.com/technetwork/database/database-technologies/berkeleydb/downloads/index.html) | 4.8.x | No |  |  |
 | Boost | [1.70.0](https://www.boost.org/users/download/) | [1.47.0](https://github.com/bitcoin/bitcoin/pull/8920) | No |  |  |
-| Clang |  | [3.3+](https://releases.llvm.org/download.html) (C++11 support) |  |  |  |
+| Clang |  | [5.0+](https://releases.llvm.org/download.html) (C++17 support) |  |  |  |
 | Expat | [2.2.7](https://libexpat.github.io/) |  | No | Yes |  |
 | fontconfig | [2.12.1](https://www.freedesktop.org/software/fontconfig/release/) |  | No | Yes |  |
 | FreeType | [2.7.1](https://download.savannah.gnu.org/releases/freetype) |  | No |  |  |
-| GCC |  | [4.8+](https://gcc.gnu.org/) (C++11 support) |  |  |  |
+| GCC |  | [7+](https://gcc.gnu.org/) (C++17 support) |  |  |  |
 | HarfBuzz-NG |  |  |  |  |  |
 | libevent | [2.1.8-stable](https://github.com/libevent/libevent/releases) | 2.0.22 | No |  |  |
 | libpng |  |  |  |  | [Yes](https://github.com/bitcoin/bitcoin/blob/master/depends/packages/qt.mk) |
diff --git a/make.sh b/make.sh
index f98d89118e..40299dac8d 100755
--- a/make.sh
+++ b/make.sh
@@ -22,7 +22,7 @@ setup_vars() {
 
     # shellcheck disable=SC2206
     # This intentionally word-splits the array as env arg can only be strings.
-    # Other options available: x86_64-w64-mingw32 x86_64-apple-darwin11
+    # Other options available: x86_64-w64-mingw32 x86_64-apple-darwin18
     TARGETS=(${TARGETS:-"x86_64-pc-linux-gnu"})
 }
 
@@ -167,7 +167,7 @@ docker_build() {
     echo "> docker-build";
 
     for target in "${targets[@]}"; do
-        if [[ "$target" == "x86_64-apple-darwin11" ]]; then
+        if [[ "$target" == "x86_64-apple-darwin18" ]]; then
             pkg_ensure_mac_sdk
         fi
         local img="${img_prefix}-${target}:${img_version}"
@@ -340,8 +340,8 @@ pkg_install_deps() {
 }
 
 pkg_ensure_mac_sdk() {
-    local sdk_name="MacOSX10.11.sdk"
-    local pkg="${sdk_name}.tar.xz"
+    local sdk_name="Xcode-11.3.1-11C505-extracted-SDK-with-libcxx-headers"
+    local pkg="${sdk_name}.tar.gz"
 
     echo "> ensuring mac sdk"
 
@@ -349,9 +349,9 @@ pkg_ensure_mac_sdk() {
     pushd ./depends/SDKs >/dev/null
     if [[ ! -d "$sdk_name" ]]; then
         if [[ ! -f "${pkg}" ]]; then
-            wget https://github.com/phracker/MacOSX-SDKs/releases/download/10.15/MacOSX10.11.sdk.tar.xz
+            wget https://bitcoincore.org/depends-sources/sdks/Xcode-11.3.1-11C505-extracted-SDK-with-libcxx-headers.tar.gz
         fi
-        tar -xvf "${pkg}"
+        tar -zxvf "${pkg}"
     fi
     rm "${pkg}" 2>/dev/null || true
     popd >/dev/null
diff --git a/src/Makefile.am b/src/Makefile.am
index 0bc3a6518e..0fd2d8b98f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -193,7 +193,6 @@ DEFI_CORE_H = \
   node/psbt.h \
   node/transaction.h \
   noui.h \
-  optional.h \
   outputtype.h \
   policy/feerate.h \
   policy/fees.h \
@@ -245,7 +244,6 @@ DEFI_CORE_H = \
   util/error.h \
   util/fees.h \
   util/system.h \
-  util/memory.h \
   util/moneystr.h \
   util/rbf.h \
   util/string.h \
diff --git a/src/addrman.cpp b/src/addrman.cpp
index 96252bd93f..e82e0dfc32 100644
--- a/src/addrman.cpp
+++ b/src/addrman.cpp
@@ -5,6 +5,7 @@
 
 #include <addrman.h>
 
+#include <cmath>
 #include <hash.h>
 #include <serialize.h>
 
@@ -59,7 +60,7 @@ double CAddrInfo::GetChance(int64_t nNow) const
         fChance *= 0.01;
 
     // deprioritize 66% after each failed attempt, but at most 1/28th to avoid the search taking forever or overly penalizing outages.
-    fChance *= pow(0.66, std::min(nAttempts, 8));
+    fChance *= std::pow(0.66, std::min(nAttempts, 8));
 
     return fChance;
 }
diff --git a/src/bench/checkqueue.cpp b/src/bench/checkqueue.cpp
index 684b45f654..ac4551bd8d 100644
--- a/src/bench/checkqueue.cpp
+++ b/src/bench/checkqueue.cpp
@@ -6,10 +6,9 @@
 #include <util/system.h>
 #include <checkqueue.h>
 #include <prevector.h>
-#include <vector>
-#include <boost/thread/thread.hpp>
 #include <random.h>
 
+#include <vector>
 
 static const int MIN_CORES = 2;
 static const size_t BATCHES = 101;
@@ -36,10 +35,7 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::State& state)
         void swap(PrevectorJob& x){p.swap(x.p);};
     };
     CCheckQueue<PrevectorJob> queue {QUEUE_BATCH_SIZE};
-    boost::thread_group tg;
-    for (auto x = 0; x < std::max(MIN_CORES, GetNumCores()); ++x) {
-       tg.create_thread([&]{queue.Thread();});
-    }
+    queue.StartWorkerThreads(GetNumCores() - 1);
     while (state.KeepRunning()) {
         // Make insecure_rand here so that each iteration is identical.
         FastRandomContext insecure_rand(true);
@@ -55,7 +51,6 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::State& state)
         // it is done explicitly here for clarity
         control.Wait();
     }
-    tg.interrupt_all();
-    tg.join_all();
+    queue.StopWorkerThreads();
 }
 BENCHMARK(CCheckQueueSpeedPrevectorJob, 1400);
diff --git a/src/bench/coin_selection.cpp b/src/bench/coin_selection.cpp
index 2f8c97c477..f2e3eab542 100644
--- a/src/bench/coin_selection.cpp
+++ b/src/bench/coin_selection.cpp
@@ -16,7 +16,7 @@ static void addCoin(const CAmount& nValue, const CWallet& wallet, std::vector<st
     tx.nLockTime = nextLockTime++; // so all transactions get different hashes
     tx.vout.resize(1);
     tx.vout[0].nValue = nValue;
-    wtxs.push_back(MakeUnique<CWalletTx>(&wallet, MakeTransactionRef(std::move(tx))));
+    wtxs.push_back(std::make_unique<CWalletTx>(&wallet, MakeTransactionRef(std::move(tx))));
 }
 
 // Simple benchmark for wallet coin selection. Note that it maybe be necessary
@@ -70,7 +70,7 @@ static void add_coin(const CAmount& nValue, int nInput, std::vector<OutputGroup>
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
-    std::unique_ptr<CWalletTx> wtx = MakeUnique<CWalletTx>(&testWallet, MakeTransactionRef(std::move(tx)));
+    std::unique_ptr<CWalletTx> wtx = std::make_unique<CWalletTx>(&testWallet, MakeTransactionRef(std::move(tx)));
     set.emplace_back(COutput(wtx.get(), nInput, 0, true, true, true).GetInputCoin(), 0, true, 0, 0);
     wtxn.emplace_back(std::move(wtx));
 }
diff --git a/src/bench/examples.cpp b/src/bench/examples.cpp
index e4d1708aff..f03eaf4173 100644
--- a/src/bench/examples.cpp
+++ b/src/bench/examples.cpp
@@ -10,7 +10,7 @@
 static void Sleep100ms(benchmark::State& state)
 {
     while (state.KeepRunning()) {
-        MilliSleep(100);
+        UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
diff --git a/src/bench/wallet_balance.cpp b/src/bench/wallet_balance.cpp
index a0889b97f3..8412920a2a 100644
--- a/src/bench/wallet_balance.cpp
+++ b/src/bench/wallet_balance.cpp
@@ -4,11 +4,12 @@
 
 #include <bench/bench.h>
 #include <interfaces/chain.h>
-#include <optional.h>
 #include <test/util.h>
 #include <validationinterface.h>
 #include <wallet/wallet.h>
 
+#include <optional>
+
 static void WalletBalance(benchmark::State& state, const bool set_dirty, const bool add_watchonly, const bool add_mine)
 {
     const auto& ADDRESS_WATCHONLY = ADDRESS_BCRT1_UNSPENDABLE;
@@ -22,11 +23,11 @@ static void WalletBalance(benchmark::State& state, const bool set_dirty, const b
     }
 
 
-    const Optional<std::string> address_mine{add_mine ? Optional<std::string>{getnewaddress(wallet)} : nullopt};
+    const std::optional<std::string> address_mine{add_mine ? std::optional<std::string>{getnewaddress(wallet)} : std::nullopt};
     if (add_watchonly) importaddress(wallet, ADDRESS_WATCHONLY);
 
     for (int i = 0; i < 100; ++i) {
-        generatetoaddress(address_mine.get_value_or(ADDRESS_WATCHONLY));
+        generatetoaddress(address_mine.value_or(ADDRESS_WATCHONLY));
         generatetoaddress(ADDRESS_WATCHONLY);
     }
     SyncWithValidationInterfaceQueue();
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index d315507db8..b994dc3f85 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -14,11 +14,11 @@
 #include <util/strencodings.h>
 #include <versionbitsinfo.h>
 
+#include <algorithm>
 #include <cassert>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
 
 std::vector<CTransactionRef> CChainParams::CreateGenesisMasternodes()
 {
@@ -32,15 +32,15 @@ std::vector<CTransactionRef> CChainParams::CreateGenesisMasternodes()
         txNew.vin[0].scriptSig = CScript(); // << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
 
         CTxDestination operatorDest = DecodeDestination(addrs.operatorAddress, *this);
-        assert(operatorDest.which() == PKHashType || operatorDest.which() == WitV0KeyHashType);
+        assert(operatorDest.index() == PKHashType || operatorDest.index() == WitV0KeyHashType);
         CTxDestination ownerDest = DecodeDestination(addrs.ownerAddress, *this);
-        assert(ownerDest.which() == PKHashType || ownerDest.which() == WitV0KeyHashType);
+        assert(ownerDest.index() == PKHashType || ownerDest.index() == WitV0KeyHashType);
 
-        CKeyID operatorAuthKey = operatorDest.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&operatorDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest)) ;
+        CKeyID operatorAuthKey = operatorDest.index() == PKHashType ? CKeyID(std::get<PKHash>(operatorDest)) : CKeyID(std::get<WitnessV0KeyHash>(operatorDest)) ;
         genesisTeam.insert(operatorAuthKey);
         CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
         metadata << static_cast<unsigned char>(CustomTxType::CreateMasternode)
-                 << static_cast<char>(operatorDest.which()) << operatorAuthKey;
+                 << static_cast<char>(operatorDest.index()) << operatorAuthKey;
 
         CScript scriptMeta;
         scriptMeta << OP_RETURN << ToByteVector(metadata);
@@ -879,11 +879,11 @@ class CRegTestParams : public CChainParams {
 };
 
 /// Check for fork height based flag, validate and set the value to a target var
-boost::optional<int> UpdateHeightValidation(const std::string& argName, const std::string& argFlag, int& argTarget) {
+std::optional<int> UpdateHeightValidation(const std::string& argName, const std::string& argFlag, int& argTarget) {
     if (gArgs.IsArgSet(argFlag)) {
         int64_t height = gArgs.GetArg(argFlag, argTarget);
         if (height < -1 || height >= std::numeric_limits<int>::max()) {
-            auto lowerArgName = boost::to_lower_copy(argName);
+            std::string lowerArgName = ToLower(argFlag);
             throw std::runtime_error(strprintf(
                 "Activation height %ld for %s is out of valid range. Use -1 to disable %s.",
                 height, argName, lowerArgName));
@@ -908,7 +908,7 @@ void CRegTestParams::UpdateActivationParametersFromArgs(const ArgsManager& args)
     UpdateHeightValidation("Dakota Crescent", "-dakotacrescentheight", consensus.DakotaCrescentHeight);
     auto eunosHeight = UpdateHeightValidation("Eunos", "-eunosheight", consensus.EunosHeight);
     if (eunosHeight.has_value()){
-        consensus.EunosKampungHeight = static_cast<int>(eunosHeight.get());
+        consensus.EunosKampungHeight = static_cast<int>(eunosHeight.value());
     }
     UpdateHeightValidation("Eunos Paya", "-eunospayaheight", consensus.EunosPayaHeight);
     UpdateHeightValidation("Fork canning", "-fortcanningheight", consensus.FortCanningHeight);
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 95b7836b52..fc2526f43e 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -7,7 +7,6 @@
 
 #include <tinyformat.h>
 #include <util/system.h>
-#include <util/memory.h>
 
 #include <assert.h>
 
@@ -37,13 +36,13 @@ const CBaseChainParams& BaseParams()
 std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain)
 {
     if (chain == CBaseChainParams::MAIN)
-        return MakeUnique<CBaseChainParams>("", 8554);
+        return std::make_unique<CBaseChainParams>("", 8554);
     else if (chain == CBaseChainParams::TESTNET)
-        return MakeUnique<CBaseChainParams>("testnet3", 18554);
+        return std::make_unique<CBaseChainParams>("testnet3", 18554);
     else if (chain == CBaseChainParams::DEVNET)
-        return MakeUnique<CBaseChainParams>("devnet", 20554);
+        return std::make_unique<CBaseChainParams>("devnet", 20554);
     else if (chain == CBaseChainParams::REGTEST)
-        return MakeUnique<CBaseChainParams>("regtest", 19554);
+        return std::make_unique<CBaseChainParams>("regtest", 19554);
     else
         throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
 }
diff --git a/src/checkqueue.h b/src/checkqueue.h
index 4cdc74e565..19599d556b 100644
--- a/src/checkqueue.h
+++ b/src/checkqueue.h
@@ -6,13 +6,12 @@
 #define DEFI_CHECKQUEUE_H
 
 #include <sync.h>
+#include <tinyformat.h>
+#include <util/threadnames.h>
 
 #include <algorithm>
 #include <vector>
 
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/mutex.hpp>
-
 template <typename T>
 class CCheckQueueControl;
 
@@ -31,67 +30,69 @@ class CCheckQueue
 {
 private:
     //! Mutex to protect the inner state
-    boost::mutex mutex;
+    Mutex m_mutex;
 
     //! Worker threads block on this when out of work
-    boost::condition_variable condWorker;
+    std::condition_variable m_worker_cv;
 
     //! Master thread blocks on this when out of work
-    boost::condition_variable condMaster;
+    std::condition_variable m_master_cv;
 
     //! The queue of elements to be processed.
     //! As the order of booleans doesn't matter, it is used as a LIFO (stack)
-    std::vector<T> queue;
+    std::vector<T> queue GUARDED_BY(m_mutex);
 
     //! The number of workers (including the master) that are idle.
-    int nIdle;
+    int nIdle GUARDED_BY(m_mutex){0};
 
     //! The total number of workers (including the master).
-    int nTotal;
+    int nTotal GUARDED_BY(m_mutex){0};
 
     //! The temporary evaluation result.
-    bool fAllOk;
+    bool fAllOk GUARDED_BY(m_mutex){true};
 
     /**
      * Number of verifications that haven't completed yet.
      * This includes elements that are no longer queued, but still in the
      * worker's own batches.
      */
-    unsigned int nTodo;
+    unsigned int nTodo GUARDED_BY(m_mutex){0};
 
     //! The maximum number of elements to be processed in one batch
-    unsigned int nBatchSize;
+    const unsigned int nBatchSize;
+
+    std::vector<std::thread> m_worker_threads;
+    bool m_request_stop GUARDED_BY(m_mutex){false};
 
     /** Internal function that does bulk of the verification work. */
-    bool Loop(bool fMaster = false)
+    bool Loop(bool fMaster)
     {
-        boost::condition_variable& cond = fMaster ? condMaster : condWorker;
+        std::condition_variable& cond = fMaster ? m_master_cv : m_worker_cv;
         std::vector<T> vChecks;
         vChecks.reserve(nBatchSize);
         unsigned int nNow = 0;
         bool fOk = true;
         do {
             {
-                boost::unique_lock<boost::mutex> lock(mutex);
+                WAIT_LOCK(m_mutex, lock);
                 // first do the clean-up of the previous loop run (allowing us to do it in the same critsect)
                 if (nNow) {
                     fAllOk &= fOk;
                     nTodo -= nNow;
                     if (nTodo == 0 && !fMaster)
                         // We processed the last element; inform the master it can exit and return the result
-                        condMaster.notify_one();
+                        m_master_cv.notify_one();
                 } else {
                     // first iteration
                     nTotal++;
                 }
                 // logically, the do loop starts here
-                while (queue.empty()) {
+                while (queue.empty() && !m_request_stop) {
                     if (fMaster && nTodo == 0) {
                         nTotal--;
                         bool fRet = fAllOk;
                         // reset the status for new work later
-                        if (fMaster)
-                            fAllOk = true;
+                        fAllOk = true;
                         // return the current status
                         return fRet;
                     }
@@ -99,6 +100,10 @@ class CCheckQueue
                     cond.wait(lock); // wait
                     nIdle--;
                 }
+                if (m_request_stop) {
+                    return false;
+                }
+
                 // Decide how many work units to process now.
                 // * Do not try to do everything at once, but aim for increasingly smaller batches so
                 //   all workers finish approximately simultaneously.
@@ -125,15 +130,27 @@ class CCheckQueue
 
 public:
     //! Mutex to ensure only one concurrent CCheckQueueControl
-    boost::mutex ControlMutex;
+    Mutex m_control_mutex;
 
     //! Create a new check queue
-    explicit CCheckQueue(unsigned int nBatchSizeIn) : nIdle(0), nTotal(0), fAllOk(true), nTodo(0), nBatchSize(nBatchSizeIn) {}
+    explicit CCheckQueue(unsigned int nBatchSizeIn) : nBatchSize(nBatchSizeIn) {}
 
-    //! Worker thread
-    void Thread()
+    //! Create a pool of new worker threads.
+    void StartWorkerThreads(const int threads_num)
     {
-        Loop();
+        {
+            LOCK(m_mutex);
+            nIdle = 0;
+            nTotal = 0;
+            fAllOk = true;
+        }
+        assert(m_worker_threads.empty());
+        for (int n = 0; n < threads_num; ++n) {
+            m_worker_threads.emplace_back([this, n]() {
+                util::ThreadRename(strprintf("scriptch.%i", n));
+                Loop(false /* worker thread */);
+            });
+        }
     }
 
     //! Wait until execution finishes, and return whether all evaluations were successful.
@@ -145,20 +162,33 @@ class CCheckQueue
     //! Add a batch of checks to the queue
     void Add(std::vector<T>& vChecks)
     {
-        boost::unique_lock<boost::mutex> lock(mutex);
+        LOCK(m_mutex);
         for (T& check : vChecks) {
             queue.push_back(T());
             check.swap(queue.back());
         }
         nTodo += vChecks.size();
         if (vChecks.size() == 1)
-            condWorker.notify_one();
+            m_worker_cv.notify_one();
         else if (vChecks.size() > 1)
-            condWorker.notify_all();
+            m_worker_cv.notify_all();
+    }
+
+    //! Stop all of the worker threads.
+    void StopWorkerThreads()
+    {
+        WITH_LOCK(m_mutex, m_request_stop = true);
+        m_worker_cv.notify_all();
+        for (std::thread& t : m_worker_threads) {
+            t.join();
+        }
+        m_worker_threads.clear();
+        WITH_LOCK(m_mutex, m_request_stop = false);
     }
 
     ~CCheckQueue()
     {
+        assert(m_worker_threads.empty());
     }
 
 };
@@ -182,7 +212,7 @@ class CCheckQueueControl
     {
         // passed queue is supposed to be unused, or nullptr
         if (pqueue != nullptr) {
-            ENTER_CRITICAL_SECTION(pqueue->ControlMutex);
+            ENTER_CRITICAL_SECTION(pqueue->m_control_mutex);
         }
     }
 
@@ -206,7 +236,7 @@ class CCheckQueueControl
         if (!fDone)
             Wait();
         if (pqueue != nullptr) {
-            LEAVE_CRITICAL_SECTION(pqueue->ControlMutex);
+            LEAVE_CRITICAL_SECTION(pqueue->m_control_mutex);
         }
     }
 };
diff --git a/src/defi-cli.cpp b/src/defi-cli.cpp
index 06e958c326..b6342d7e97 100644
--- a/src/defi-cli.cpp
+++ b/src/defi-cli.cpp
@@ -483,7 +483,7 @@ static int CommandLineRPC(int argc, char *argv[])
             }
             catch (const CConnectionFailed&) {
                 if (fWait)
-                    MilliSleep(1000);
+                    UninterruptibleSleep(std::chrono::milliseconds{1000});
                 else
                     throw;
             }
diff --git a/src/defid.cpp b/src/defid.cpp
index a05d699adb..517b357d3c 100644
--- a/src/defid.cpp
+++ b/src/defid.cpp
@@ -47,7 +47,7 @@ static void WaitForShutdown()
 {
     while (!ShutdownRequested())
     {
-        MilliSleep(200);
+        UninterruptibleSleep(std::chrono::milliseconds{200});
     }
     Interrupt();
 }
diff --git a/src/flushablestorage.h b/src/flushablestorage.h
index c9a9ffcea1..0cba8924c7 100644
--- a/src/flushablestorage.h
+++ b/src/flushablestorage.h
@@ -5,16 +5,17 @@
 #ifndef DEFI_FLUSHABLESTORAGE_H
 #define DEFI_FLUSHABLESTORAGE_H
 
+#include <shutdown.h>
+
 #include <dbwrapper.h>
 #include <functional>
-#include <optional.h>
 #include <map>
 #include <memusage.h>
 
-#include <boost/thread.hpp>
+#include <optional>
 
 using TBytes = std::vector<unsigned char>;
-using MapKV = std::map<TBytes, Optional<TBytes>>;
+using MapKV = std::map<TBytes, std::optional<TBytes>>;
 
 template<typename T>
 static TBytes DbTypeToBytes(const T& value) {
@@ -166,7 +167,7 @@ class CStorageLevelDB : public CStorageKV {
         return batch.SizeEstimate();
     }
     std::unique_ptr<CStorageKVIterator> NewIterator() override {
-        return MakeUnique<CStorageLevelDBIterator>(std::unique_ptr<CDBIterator>(db.NewIterator()));
+        return std::make_unique<CStorageLevelDBIterator>(std::unique_ptr<CDBIterator>(db.NewIterator()));
     }
     void Compact(const TBytes& begin, const TBytes& end) {
         db.CompactRange(refTBytes(begin), refTBytes(end));
@@ -291,7 +292,7 @@ class CFlushableStorageKV : public CStorageKV {
         if (it == changed.end()) {
             return db.Read(key, value);
         } else if (it->second) {
-            value = it->second.get();
+            value = it->second.value();
             return true;
         } else {
             return false;
@@ -303,7 +304,7 @@ class CFlushableStorageKV : public CStorageKV {
                 if (!db.Erase(it.first)) {
                     return false;
                 }
-            } else if (!db.Write(it.first, it.second.get())) {
+            } else if (!db.Write(it.first, it.second.value())) {
                 return false;
             }
         }
@@ -317,7 +318,7 @@ class CFlushableStorageKV : public CStorageKV {
         return memusage::DynamicUsage(changed);
     }
     std::unique_ptr<CStorageKVIterator> NewIterator() override {
-        return MakeUnique<CFlushableStorageKVIterator>(db.NewIterator(), changed);
+        return std::make_unique<CFlushableStorageKVIterator>(db.NewIterator(), changed);
     }
 
     MapKV& GetRaw() {
@@ -331,7 +332,7 @@ class CFlushableStorageKV : public CStorageKV {
 
 template<typename T>
 class CLazySerialize {
-    Optional<T> value;
+    std::optional<T> value;
     std::unique_ptr<CStorageKVIterator>& it;
 
 public:
@@ -427,8 +428,8 @@ class CStorageIteratorWrapper {
 // Creates an iterator to single level key value storage
 template<typename By, typename KeyType>
 CStorageIteratorWrapper<By, KeyType> NewKVIterator(const KeyType& key, MapKV& map) {
-    auto emptyParent = MakeUnique<CStorageKVEmptyIterator>();
-    auto flushableIterator = MakeUnique<CFlushableStorageKVIterator>(std::move(emptyParent), map);
+    auto emptyParent = std::make_unique<CStorageKVEmptyIterator>();
+    auto flushableIterator = std::make_unique<CFlushableStorageKVIterator>(std::move(emptyParent), map);
     CStorageIteratorWrapper<By, KeyType> it{std::move(flushableIterator)};
     it.Seek(key);
     return it;
@@ -482,7 +483,7 @@ class CStorageView {
     }
     // second type of 'ReadBy' (may be 'GetBy'?)
     template<typename By, typename ResultType, typename KeyType>
-    boost::optional<ResultType> ReadBy(KeyType const & id) const {
+    std::optional<ResultType> ReadBy(KeyType const & id) const {
         ResultType result;
         if (ReadBy<By>(id, result))
             return {result};
@@ -497,7 +498,9 @@ class CStorageView {
     template<typename By, typename KeyType, typename ValueType>
     void ForEach(std::function<bool(KeyType const &, CLazySerialize<ValueType>)> callback, KeyType const & start = {}) {
         for(auto it = LowerBound<By>(start); it.Valid(); it.Next()) {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) {
+                break;
+            }
 
             if (!callback(it.Key(), it.Value())) {
                 break;
diff --git a/src/httprpc.cpp b/src/httprpc.cpp
index 8dfc133351..e53fb0edaa 100644
--- a/src/httprpc.cpp
+++ b/src/httprpc.cpp
@@ -196,7 +196,7 @@ static bool HTTPReq_JSONRPC(HTTPRequest* req, const std::string &)
         /* Deter brute-forcing
            If this results in a DoS the user really
            shouldn't have their RPC port exposed. */
-        MilliSleep(250);
+        UninterruptibleSleep(std::chrono::milliseconds{250});
 
         req->WriteHeader("WWW-Authenticate", WWW_AUTH_HEADER_DATA);
         req->WriteReply(HTTP_UNAUTHORIZED);
@@ -277,7 +277,7 @@ bool StartHTTPRPC()
     }
     struct event_base* eventBase = EventBase();
     assert(eventBase);
-    httpRPCTimerInterface = MakeUnique<HTTPRPCTimerInterface>(eventBase);
+    httpRPCTimerInterface = std::make_unique<HTTPRPCTimerInterface>(eventBase);
     RPCSetTimerInterface(httpRPCTimerInterface.get());
     return true;
 }
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index f45cd06e41..849bbb5159 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -107,8 +107,8 @@ BlockFilterIndex::BlockFilterIndex(BlockFilterType filter_type,
     fs::create_directories(path);
 
     m_name = filter_name + " block filter index";
-    m_db = MakeUnique<BaseIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
-    m_filter_fileseq = MakeUnique<FlatFileSeq>(std::move(path), "fltr", FLTR_FILE_CHUNK_SIZE);
+    m_db = std::make_unique<BaseIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
+    m_filter_fileseq = std::make_unique<FlatFileSeq>(std::move(path), "fltr", FLTR_FILE_CHUNK_SIZE);
 }
 
 bool BlockFilterIndex::Init()
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
index cca08fd0f9..0e46109d55 100644
--- a/src/index/txindex.cpp
+++ b/src/index/txindex.cpp
@@ -9,8 +9,6 @@
 #include <util/translation.h>
 #include <validation.h>
 
-#include <boost/thread.hpp>
-
 constexpr char DB_BEST_BLOCK = 'B';
 constexpr char DB_TXINDEX = 't';
 constexpr char DB_TXINDEX_BLOCK = 'T';
@@ -152,7 +150,6 @@ bool TxIndex::DB::MigrateData(CBlockTreeDB& block_tree_db, const CBlockLocator&
     bool interrupted = false;
     std::unique_ptr<CDBIterator> cursor(block_tree_db.NewIterator());
     for (cursor->Seek(begin_key); cursor->Valid(); cursor->Next()) {
-        boost::this_thread::interruption_point();
         if (ShutdownRequested()) {
             interrupted = true;
             break;
@@ -225,7 +222,7 @@ bool TxIndex::DB::MigrateData(CBlockTreeDB& block_tree_db, const CBlockLocator&
 }
 
 TxIndex::TxIndex(size_t n_cache_size, bool f_memory, bool f_wipe)
-    : m_db(MakeUnique<TxIndex::DB>(n_cache_size, f_memory, f_wipe))
+    : m_db(std::make_unique<TxIndex::DB>(n_cache_size, f_memory, f_wipe))
 {}
 
 TxIndex::~TxIndex() {}
diff --git a/src/init.cpp b/src/init.cpp
index 989450937f..b67fab06f7 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -9,7 +9,6 @@
 
 #include <init.h>
 
-#include <addrman.h>
 #include <amount.h>
 #include <banman.h>
 #include <blockfilter.h>
@@ -22,7 +21,6 @@
 #include <httpserver.h>
 #include <index/blockfilterindex.h>
 #include <index/txindex.h>
-#include <interfaces/chain.h>
 #include <key.h>
 #include <key_io.h>
 #include <masternodes/accountshistory.h>
@@ -71,10 +69,7 @@
 #include <sys/stat.h>
 #endif
 
-#include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/split.hpp>
-#include <boost/thread.hpp>
 
 #if ENABLE_ZMQ
 #include <zmq/zmqabstractnotifier.h>
@@ -157,7 +152,7 @@ NODISCARD static bool CreatePidFile()
 
 static std::unique_ptr<ECCVerifyHandle> globalVerifyHandle;
 
-static boost::thread_group threadGroup;
+std::vector<std::thread> threadGroup;
 static CScheduler scheduler;
 
 void Interrupt()
@@ -216,9 +211,12 @@ void Shutdown(InitInterfaces& interfaces)
     StopTorControl();
 
     // After everything has been shut down, but before things get flushed, stop the
-    // CScheduler/checkqueue threadGroup
-    threadGroup.interrupt_all();
-    threadGroup.join_all();
+    // CScheduler/checkqueue threaGroup
+    scheduler.stop();
+    for (auto& thread : threadGroup) {
+        if (thread.joinable()) thread.join();
+    }
+    StopScriptCheckWorkerThreads();
 
     // After the threads that potentially access these pointers have been stopped,
     // destruct and reset all to nullptr.
@@ -722,6 +720,10 @@ static void ThreadImport(std::vector<fs::path> vImportFiles)
                 break; // This error is logged in OpenBlockFile
             LogPrintf("Reindexing block file blk%05u.dat...\n", (unsigned int)nFile);
             LoadExternalBlockFile(chainparams, file, &pos);
+            if (ShutdownRequested()) {
+                LogPrintf("Shutdown requested. Exit %s\n", __func__);
+                return;
+            }
             nFile++;
         }
         pblocktree->WriteReindexing(false);
@@ -739,6 +741,10 @@ static void ThreadImport(std::vector<fs::path> vImportFiles)
             fs::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
             LogPrintf("Importing bootstrap.dat...\n");
             LoadExternalBlockFile(chainparams, file);
+            if (ShutdownRequested()) {
+                LogPrintf("Shutdown requested. Exit %s\n", __func__);
+                return;
+            }
             RenameOver(pathBootstrap, pathBootstrapOld);
         } else {
             LogPrintf("Warning: Could not open bootstrap file %s\n", pathBootstrap.string());
@@ -1109,15 +1115,6 @@ bool AppInitParameterInteraction()
         incrementalRelayFee = CFeeRate(n);
     }
 
-    // -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency
-    nScriptCheckThreads = gArgs.GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
-    if (nScriptCheckThreads <= 0)
-        nScriptCheckThreads += GetNumCores();
-    if (nScriptCheckThreads <= 1)
-        nScriptCheckThreads = 0;
-    else if (nScriptCheckThreads > MAX_SCRIPTCHECK_THREADS)
-        nScriptCheckThreads = MAX_SCRIPTCHECK_THREADS;
-
     // block pruning; get the amount of disk space (in MiB) to allot for block & undo files
     int64_t nPruneArg = gArgs.GetArg("-prune", 0);
     if (nPruneArg < 0) {
@@ -1258,7 +1255,7 @@ bool AppInitLockDataDirectory()
 void SetupAnchorSPVDatabases(bool resync) {
     // Close and open database
     panchors.reset();
-    panchors = MakeUnique<CAnchorIndex>(nDefaultDbCache << 20, false, gArgs.GetBoolArg("-spv", true) && resync);
+    panchors = std::make_unique<CAnchorIndex>(nDefaultDbCache << 20, false, gArgs.GetBoolArg("-spv", true) && resync);
 
     // load anchors after spv due to spv (and spv height) not set before (no last height yet)
     if (gArgs.GetBoolArg("-spv", true)) {
@@ -1267,11 +1264,11 @@ void SetupAnchorSPVDatabases(bool resync) {
 
         // Open database based on network
         if (Params().NetworkIDString() == "regtest") {
-            spv::pspv = MakeUnique<spv::CFakeSpvWrapper>();
+            spv::pspv = std::make_unique<spv::CFakeSpvWrapper>();
         } else if (Params().NetworkIDString() == "test" || Params().NetworkIDString() == "devnet") {
-            spv::pspv = MakeUnique<spv::CSpvWrapper>(false, nMinDbCache << 20, false, resync);
+            spv::pspv = std::make_unique<spv::CSpvWrapper>(false, nMinDbCache << 20, false, resync);
         } else {
-            spv::pspv = MakeUnique<spv::CSpvWrapper>(true, nMinDbCache << 20, false, resync);
+            spv::pspv = std::make_unique<spv::CSpvWrapper>(true, nMinDbCache << 20, false, resync);
         }
     }
 }
@@ -1327,15 +1324,27 @@ bool AppInitMain(InitInterfaces& interfaces)
     InitSignatureCache();
     InitScriptExecutionCache();
 
-    LogPrintf("Using %u threads for script verification\n", nScriptCheckThreads);
-    if (nScriptCheckThreads) {
-        for (int i=0; i<nScriptCheckThreads-1; i++)
-            threadGroup.create_thread([i]() { return ThreadScriptCheck(i); });
+    int script_threads = gArgs.GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
+    if (script_threads <= 0) {
+        // -par=0 means autodetect (number of cores - 1 script threads)
+        // -par=-n means "leave n cores free" (number of cores - n - 1 script threads)
+        script_threads += GetNumCores();
+    }
+
+    // Subtract 1 because the main thread counts towards the par threads
+    script_threads = std::max(script_threads - 1, 0);
+
+    // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
+    script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
+
+    LogPrintf("Script verification uses %d additional threads\n", script_threads);
+    if (script_threads >= 1) {
+        g_parallel_script_checks = true;
+        StartScriptCheckWorkerThreads(script_threads);
     }
 
     // Start the lightweight task scheduler thread
-    CScheduler::Function serviceLoop = std::bind(&CScheduler::serviceQueue, &scheduler);
-    threadGroup.create_thread(std::bind(&TraceThread<CScheduler::Function>, "scheduler", serviceLoop));
+    scheduler.m_service_thread = std::thread([&] { TraceThread("scheduler", [&] { scheduler.serviceQueue(); }); });
 
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
     GetMainSignals().RegisterWithMempoolSignals(mempool);
@@ -1384,7 +1393,7 @@ bool AppInitMain(InitInterfaces& interfaces)
     // need to reindex later.
 
     assert(!g_banman);
-    g_banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", &uiInterface, gArgs.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
+    g_banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", &uiInterface, gArgs.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
     assert(!g_connman);
     g_connman = std::unique_ptr<CConnman>(new CConnman(GetRand(std::numeric_limits<uint64_t>::max()), GetRand(std::numeric_limits<uint64_t>::max())));
 
@@ -1543,7 +1552,7 @@ bool AppInitMain(InitInterfaces& interfaces)
             try {
                 LOCK(cs_main);
                 // This statement makes ::ChainstateActive() usable.
-                g_chainstate = MakeUnique<CChainState>();
+                g_chainstate = std::make_unique<CChainState>();
                 UnloadBlockIndex();
 
                 // new CBlockTreeDB tries to delete the existing file, which
@@ -1608,9 +1617,9 @@ bool AppInitMain(InitInterfaces& interfaces)
                 });
 
                 pcustomcsDB.reset();
-                pcustomcsDB = MakeUnique<CStorageLevelDB>(GetDataDir() / "enhancedcs", nCustomCacheSize, false, fReset || fReindexChainState);
+                pcustomcsDB = std::make_unique<CStorageLevelDB>(GetDataDir() / "enhancedcs", nCustomCacheSize, false, fReset || fReindexChainState);
                 pcustomcsview.reset();
-                pcustomcsview = MakeUnique<CCustomCSView>(*pcustomcsDB.get());
+                pcustomcsview = std::make_unique<CCustomCSView>(*pcustomcsDB.get());
                 if (!fReset && !fReindexChainState) {
                     if (!pcustomcsDB->IsEmpty() && pcustomcsview->GetDbVersion() != CCustomCSView::DbVersion) {
                         strLoadError = _("Account database is unsuitable").translated;
@@ -1624,11 +1633,11 @@ bool AppInitMain(InitInterfaces& interfaces)
                 // make account history db
                 paccountHistoryDB.reset();
                 if (gArgs.GetBoolArg("-acindex", DEFAULT_ACINDEX)) {
-                    paccountHistoryDB = MakeUnique<CAccountHistoryStorage>(GetDataDir() / "history", nCustomCacheSize, false, fReset || fReindexChainState);
+                    paccountHistoryDB = std::make_unique<CAccountHistoryStorage>(GetDataDir() / "history", nCustomCacheSize, false, fReset || fReindexChainState);
                 }
 
                 pburnHistoryDB.reset();
-                pburnHistoryDB = MakeUnique<CBurnHistoryStorage>(GetDataDir() / "burn", nCustomCacheSize, false, fReset || fReindexChainState);
+                pburnHistoryDB = std::make_unique<CBurnHistoryStorage>(GetDataDir() / "burn", nCustomCacheSize, false, fReset || fReindexChainState);
 
                 // If necessary, upgrade from older database format.
                 // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
@@ -1745,7 +1754,7 @@ bool AppInitMain(InitInterfaces& interfaces)
 
     // ********************************************************* Step 8: start indexers
     if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
-        g_txindex = MakeUnique<TxIndex>(nTxIndexCache, false, fReindex);
+        g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);
         g_txindex->Start();
     }
 
@@ -1767,9 +1776,9 @@ bool AppInitMain(InitInterfaces& interfaces)
         LOCK(cs_main);
 
         panchorauths.reset();
-        panchorauths = MakeUnique<CAnchorAuthIndex>();
+        panchorauths = std::make_unique<CAnchorAuthIndex>();
         panchorAwaitingConfirms.reset();
-        panchorAwaitingConfirms = MakeUnique<CAnchorAwaitingConfirms>();
+        panchorAwaitingConfirms = std::make_unique<CAnchorAwaitingConfirms>();
         SetupAnchorSPVDatabases(gArgs.GetBoolArg("-spv_resync", fReindex || fReindexChainState));
 
         // Check if DB version changed
@@ -1838,7 +1847,7 @@ bool AppInitMain(InitInterfaces& interfaces)
         vImportFiles.push_back(strFile);
     }
 
-    threadGroup.create_thread(std::bind(&ThreadImport, vImportFiles));
+    threadGroup.emplace_back(ThreadImport, vImportFiles);
 
     // Wait for genesis block to be processed
     {
@@ -1977,8 +1986,8 @@ bool AppInitMain(InitInterfaces& interfaces)
             auto& coinbaseScript = stakerParams.coinbaseScript;
 
             CTxDestination destination = DecodeDestination(op);
-            operatorId = destination.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&destination)) :
-                         destination.which() == WitV0KeyHashType ? CKeyID(*boost::get<WitnessV0KeyHash>(&destination)) : CKeyID();
+            operatorId = destination.index() == PKHashType ? CKeyID(std::get<PKHash>(destination)) :
+                         destination.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(destination)) : CKeyID();
 
             if (operatorId.IsNull()) {
                 LogPrintf("Error: wrong masternode_operator address (%s)\n", op);
@@ -2045,13 +2054,11 @@ bool AppInitMain(InitInterfaces& interfaces)
         }
 
         // Mint proof-of-stake blocks in background
-        threadGroup.create_thread(
-            std::bind(TraceThread<std::function<void()>>, "CoinStaker", [=]() {
-                // Run ThreadStaker
-                pos::ThreadStaker threadStaker;
-                threadStaker(std::move(stakersParams), std::move(chainparams));
-            }
-        ));
+        threadGroup.emplace_back(TraceThread<std::function<void()>>, "CoinStaker", [=]() {
+            // Run ThreadStaker
+            pos::ThreadStaker threadStaker;
+            threadStaker(stakersParams, chainparams);
+        });
     }
 
     return true;
diff --git a/src/interfaces/chain.cpp b/src/interfaces/chain.cpp
index 70a76e5091..6f43b23e61 100644
--- a/src/interfaces/chain.cpp
+++ b/src/interfaces/chain.cpp
@@ -47,28 +47,28 @@ class LockImpl : public Chain::Lock
     LockImpl(CCriticalSection& mutex) : m_mutex(mutex)
     {
     }
-    Optional<int> getHeight() override
+    std::optional<int> getHeight() override
     {
         LockAssertion lock(m_mutex);
         int height = ::ChainActive().Height();
         if (height >= 0) {
             return height;
         }
-        return nullopt;
+        return std::nullopt;
     }
-    Optional<int> getBlockHeight(const uint256& hash) override
+    std::optional<int> getBlockHeight(const uint256& hash) override
     {
         LockAssertion lock(m_mutex);
         CBlockIndex* block = LookupBlockIndex(hash);
         if (block && ::ChainActive().Contains(block)) {
             return block->nHeight;
         }
-        return nullopt;
+        return std::nullopt;
     }
     int getBlockDepth(const uint256& hash) override
     {
-        const Optional<int> tip_height = getHeight();
-        const Optional<int> height = getBlockHeight(hash);
+        const std::optional<int> tip_height = getHeight();
+        const std::optional<int> height = getBlockHeight(hash);
         return tip_height && height ? *tip_height - *height + 1 : 0;
     }
     uint256 getBlockHash(int height) override
@@ -98,7 +98,7 @@ class LockImpl : public Chain::Lock
         CBlockIndex* block = ::ChainActive()[height];
         return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
     }
-    Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) override
+    std::optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) override
     {
         LockAssertion lock(m_mutex);
         CBlockIndex* block = ::ChainActive().FindEarliestAtLeast(time, height);
@@ -106,9 +106,9 @@ class LockImpl : public Chain::Lock
             if (hash) *hash = block->GetBlockHash();
             return block->nHeight;
         }
-        return nullopt;
+        return std::nullopt;
     }
-    Optional<int> findPruned(int start_height, Optional<int> stop_height) override
+    std::optional<int> findPruned(int start_height, std::optional<int> stop_height) override
     {
         LockAssertion lock(m_mutex);
         if (::fPruneMode) {
@@ -120,9 +120,9 @@ class LockImpl : public Chain::Lock
                 block = block->pprev;
             }
         }
-        return nullopt;
+        return std::nullopt;
     }
-    Optional<int> findFork(const uint256& hash, Optional<int>* height) override
+    std::optional<int> findFork(const uint256& hash, std::optional<int>* height) override
     {
         LockAssertion lock(m_mutex);
         const CBlockIndex* block = LookupBlockIndex(hash);
@@ -137,20 +137,20 @@ class LockImpl : public Chain::Lock
         if (fork) {
             return fork->nHeight;
         }
-        return nullopt;
+        return std::nullopt;
     }
     CBlockLocator getTipLocator() override
     {
         LockAssertion lock(m_mutex);
         return ::ChainActive().GetLocator();
     }
-    Optional<int> findLocatorFork(const CBlockLocator& locator) override
+    std::optional<int> findLocatorFork(const CBlockLocator& locator) override
     {
         LockAssertion lock(m_mutex);
         if (CBlockIndex* fork = FindForkInGlobalIndex(::ChainActive(), locator)) {
             return fork->nHeight;
         }
-        return nullopt;
+        return std::nullopt;
     }
     bool checkFinalTx(const CTransaction& tx) override
     {
@@ -250,7 +250,7 @@ class ChainImpl : public Chain
 public:
     std::unique_ptr<Chain::Lock> lock() override
     {
-        return MakeUnique<LockImpl>(::cs_main);
+        return std::make_unique<LockImpl>(::cs_main);
     }
     bool findBlock(const uint256& hash, CBlock* block, int64_t* time, int64_t* time_max) override
     {
@@ -280,7 +280,7 @@ class ChainImpl : public Chain
         return pcustomcsview->CanSpend(nodeId, height);
     }
 
-    boost::optional<CMasternode> mnExists(const uint256 & nodeId) const override
+    std::optional<CMasternode> mnExists(const uint256 & nodeId) const override
     {
         LOCK(cs_main);
         return pcustomcsview->GetMasternode(nodeId);
@@ -365,7 +365,7 @@ class ChainImpl : public Chain
     }
     std::unique_ptr<Handler> handleNotifications(Notifications& notifications) override
     {
-        return MakeUnique<NotificationsHandlerImpl>(*this, notifications);
+        return std::make_unique<NotificationsHandlerImpl>(*this, notifications);
     }
     void waitForNotificationsIfNewBlocksConnected(const uint256& old_tip) override
     {
@@ -379,7 +379,7 @@ class ChainImpl : public Chain
     }
     std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
     {
-        return MakeUnique<RpcHandlerImpl>(command);
+        return std::make_unique<RpcHandlerImpl>(command);
     }
     bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
     void rpcRunLater(const std::string& name, std::function<void()> fn, int64_t seconds) override
@@ -397,6 +397,6 @@ class ChainImpl : public Chain
 };
 } // namespace
 
-std::unique_ptr<Chain> MakeChain() { return MakeUnique<ChainImpl>(); }
+std::unique_ptr<Chain> MakeChain() { return std::make_unique<ChainImpl>(); }
 
 } // namespace interfaces
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index 8c904912bd..22f10827cd 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -5,11 +5,12 @@
 #ifndef DEFI_INTERFACES_CHAIN_H
 #define DEFI_INTERFACES_CHAIN_H
 
-#include <optional.h>               // For Optional and nullopt
 #include <primitives/transaction.h> // For CTransactionRef
 #include <sync.h>
 
+#include <functional>
 #include <memory>
+#include <optional>
 #include <stddef.h>
 #include <stdint.h>
 #include <string>
@@ -71,12 +72,12 @@ class Chain
         //! Get current chain height, not including genesis block (returns 0 if
         //! chain only contains genesis block, nullopt if chain does not contain
         //! any blocks).
-        virtual Optional<int> getHeight() = 0;
+        virtual std::optional<int> getHeight() = 0;
 
         //! Get block height above genesis block. Returns 0 for genesis block,
         //! 1 for following block, and so on. Returns nullopt for a block not
         //! included in the current chain.
-        virtual Optional<int> getBlockHeight(const uint256& hash) = 0;
+        virtual std::optional<int> getBlockHeight(const uint256& hash) = 0;
 
         //! Get block depth. Returns 1 for chain tip, 2 for preceding block, and
         //! so on. Returns 0 for a block not included in the current chain.
@@ -101,11 +102,11 @@ class Chain
         //! given height, or nullopt if there is no block with a high enough
         //! timestamp and height. Also return the block hash as an optional output parameter
         //! (to avoid the cost of a second lookup in case this information is needed.)
-        virtual Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) = 0;
+        virtual std::optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) = 0;
 
         //! Return height of last block in the specified range which is pruned, or
         //! nullopt if no block in the range is pruned. Range is inclusive.
-        virtual Optional<int> findPruned(int start_height = 0, Optional<int> stop_height = nullopt) = 0;
+        virtual std::optional<int> findPruned(int start_height = 0, std::optional<int> stop_height = std::nullopt) = 0;
 
         //! Return height of the specified block if it is on the chain, otherwise
         //! return the height of the highest block on chain that's an ancestor
@@ -113,7 +114,7 @@ class Chain
         //! Also return the height of the specified block as an optional output
         //! parameter (to avoid the cost of a second hash lookup in case this
         //! information is desired).
-        virtual Optional<int> findFork(const uint256& hash, Optional<int>* height) = 0;
+        virtual std::optional<int> findFork(const uint256& hash, std::optional<int>* height) = 0;
 
         //! Get locator for the current chain tip.
         virtual CBlockLocator getTipLocator() = 0;
@@ -121,7 +122,7 @@ class Chain
         //! Return height of the highest block on chain in common with the locator,
         //! which will either be the original block used to create the locator,
         //! or one of its ancestors.
-        virtual Optional<int> findLocatorFork(const CBlockLocator& locator) = 0;
+        virtual std::optional<int> findLocatorFork(const CBlockLocator& locator) = 0;
 
         //! Check if transaction will be final given chain height current time.
         virtual bool checkFinalTx(const CTransaction& tx) = 0;
@@ -151,7 +152,7 @@ class Chain
     virtual void findCoins(std::map<COutPoint, Coin>& coins) = 0;
 
     virtual bool mnCanSpend(const uint256 & nodeId, int height) const = 0;
-    virtual boost::optional<CMasternode> mnExists(const uint256 & nodeId) const = 0;
+    virtual std::optional<CMasternode> mnExists(const uint256 & nodeId) const = 0;
     virtual std::unique_ptr<CToken> existTokenGuessId(const std::string & str, DCT_ID & id) const = 0;
 
     //! Estimate fraction of total transactions verified if blocks up to
diff --git a/src/interfaces/handler.cpp b/src/interfaces/handler.cpp
index 0262ec712f..eb3d257328 100644
--- a/src/interfaces/handler.cpp
+++ b/src/interfaces/handler.cpp
@@ -4,7 +4,6 @@
 
 #include <interfaces/handler.h>
 
-#include <util/memory.h>
 
 #include <boost/signals2/connection.hpp>
 #include <utility>
@@ -26,7 +25,7 @@ class HandlerImpl : public Handler
 
 std::unique_ptr<Handler> MakeHandler(boost::signals2::connection connection)
 {
-    return MakeUnique<HandlerImpl>(std::move(connection));
+    return std::make_unique<HandlerImpl>(std::move(connection));
 }
 
 } // namespace interfaces
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 126d92d9da..29e5378554 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -5,19 +5,13 @@
 #include <base58.h>
 #include <bech32.h>
 #include <chainparams.h>
-#include <script/script.h>
 #include <util/strencodings.h>
 
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/static_visitor.hpp>
-
 #include <assert.h>
 #include <string.h>
-#include <algorithm>
 
-namespace
-{
-class DestinationEncoder : public boost::static_visitor<std::string>
+namespace {
+class DestinationEncoder
 {
 private:
     const CChainParams& m_params;
@@ -209,7 +203,7 @@ std::string EncodeExtKey(const CExtKey& key)
 
 std::string EncodeDestination(const CTxDestination& dest)
 {
-    return boost::apply_visitor(DestinationEncoder(Params()), dest);
+    return std::visit(DestinationEncoder(Params()), dest);
 }
 
 CTxDestination DecodeDestination(const std::string& str)
@@ -228,9 +222,9 @@ bool IsValidDestinationString(const std::string& str)
 }
 
 CKeyID getCKeyIDFromDestination(const CTxDestination& dest) {
-  switch (dest.which()) {
-    case PKHashType       : return CKeyID(*boost::get<PKHash>(&dest));
-    case WitV0KeyHashType : return CKeyID(*boost::get<WitnessV0KeyHash>(&dest));
-    default               : return CKeyID();
+  switch (dest.index()) {
+    case PKHashType       : return CKeyID(std::get<PKHash>(dest));
+    case WitV0KeyHashType : return CKeyID(std::get<WitnessV0KeyHash>(dest));
+    default               : return {};
   }
 }
diff --git a/src/masternodes/anchors.cpp b/src/masternodes/anchors.cpp
index 092161981c..45a259db9c 100644
--- a/src/masternodes/anchors.cpp
+++ b/src/masternodes/anchors.cpp
@@ -70,7 +70,7 @@ CKeyID CAnchorAuthMessage::GetSigner() const
 CAnchor CAnchor::Create(const std::vector<CAnchorAuthMessage> & auths, CTxDestination const & rewardDest)
 {
     // assumed here that all of the auths are uniform, were checked for sigs and consensus has been reached!
-    assert(rewardDest.which() == PKHashType || rewardDest.which() == WitV0KeyHashType);
+    assert(rewardDest.index() == PKHashType || rewardDest.index() == WitV0KeyHashType);
 
     if (auths.size() > 0) {
         CAnchor anchor(static_cast<CAnchorData const &> (auths.at(0)));
@@ -78,8 +78,8 @@ CAnchor CAnchor::Create(const std::vector<CAnchorAuthMessage> & auths, CTxDestin
         for (size_t i = 0; i < auths.size(); ++i) {
             anchor.sigs.push_back(auths[i].GetSignature());
         }
-        anchor.rewardKeyID = rewardDest.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&rewardDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&rewardDest));
-        anchor.rewardKeyType = rewardDest.which();
+        anchor.rewardKeyID = rewardDest.index() == PKHashType ? CKeyID(std::get<PKHash>(rewardDest)) : CKeyID(std::get<WitnessV0KeyHash>(rewardDest));
+        anchor.rewardKeyType = rewardDest.index();
         return anchor;
     }
     return {};
@@ -914,7 +914,7 @@ uint256 CAnchorConfirmDataPlus::GetSignHash() const
     return Hash(ss.begin(), ss.end());
 }
 
-boost::optional<CAnchorConfirmMessage> CAnchorConfirmMessage::CreateSigned(const CAnchor& anchor, const THeight prevAnchorHeight,
+std::optional<CAnchorConfirmMessage> CAnchorConfirmMessage::CreateSigned(const CAnchor& anchor, const THeight prevAnchorHeight,
                                                                            const uint256 &btcTxHash, CKey const & key, const THeight btcTxHeight)
 {
     // Potential post-fork unrewarded anchor
diff --git a/src/masternodes/anchors.h b/src/masternodes/anchors.h
index d5f54882d7..7c1ca0f139 100644
--- a/src/masternodes/anchors.h
+++ b/src/masternodes/anchors.h
@@ -9,14 +9,12 @@
 #include <script/script.h>
 #include <script/standard.h>
 #include <serialize.h>
+#include <shutdown.h>
 #include <uint256.h>
 
 #include <functional>
 #include <vector>
 
-#include <boost/scoped_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/mem_fun.hpp>
 #include <boost/multi_index/member.hpp>
@@ -25,8 +23,6 @@
 #include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 
-#include <boost/thread.hpp>
-
 #include <dbwrapper.h>
 
 class CBlockIndex;
@@ -189,8 +185,8 @@ class CAnchorAuthIndex
 class CAnchorIndex
 {
 private:
-    boost::shared_ptr<CDBWrapper> db;
-    boost::scoped_ptr<CDBBatch> batch;
+    std::shared_ptr<CDBWrapper> db;
+    std::unique_ptr<CDBBatch> batch;
 public:
     using Signature = std::vector<unsigned char>;
     using CTeam = CAnchorData::CTeam;
@@ -275,12 +271,12 @@ class CAnchorIndex
     template <typename Key, typename Value>
     bool IterateTable(char prefix, std::function<void(Key const &, Value &)> callback)
     {
-        boost::scoped_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
+        std::unique_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
         pcursor->Seek(prefix);
 
         while (pcursor->Valid())
         {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) break;
             std::pair<char, Key> key;
             if (pcursor->GetKey(key) && key.first == prefix)
             {
@@ -403,7 +399,7 @@ class CAnchorConfirmMessage : public CAnchorConfirmDataPlus
         , signature()
     {}
 
-    static boost::optional<CAnchorConfirmMessage> CreateSigned(const CAnchor &anchor, const THeight prevAnchorHeight,
+    static std::optional<CAnchorConfirmMessage> CreateSigned(const CAnchor &anchor, const THeight prevAnchorHeight,
                                                                const uint256 &btcTxHash, CKey const & key, const THeight btcTxHeight);
     uint256 GetHash() const;
     CKeyID GetSigner() const;
diff --git a/src/masternodes/icxorder.cpp b/src/masternodes/icxorder.cpp
index e68827062d..1f84d4abd3 100644
--- a/src/masternodes/icxorder.cpp
+++ b/src/masternodes/icxorder.cpp
@@ -46,7 +46,7 @@ std::unique_ptr<CICXOrderView::CICXOrderImpl> CICXOrderView::GetICXOrderByCreati
 {
     auto order = ReadBy<ICXOrderCreationTx,CICXOrderImpl>(txid);
     if (order)
-        return MakeUnique<CICXOrderImpl>(*order);
+        return std::make_unique<CICXOrderImpl>(*order);
     return {};
 }
 
@@ -138,7 +138,7 @@ std::unique_ptr<CICXOrderView::CICXMakeOfferImpl> CICXOrderView::GetICXMakeOffer
 {
     auto makeoffer = ReadBy<ICXMakeOfferCreationTx,CICXMakeOfferImpl>(txid);
     if (makeoffer)
-        return MakeUnique<CICXMakeOfferImpl>(*makeoffer);
+        return std::make_unique<CICXMakeOfferImpl>(*makeoffer);
     return {};
 }
 
@@ -214,7 +214,7 @@ std::unique_ptr<CICXOrderView::CICXSubmitDFCHTLCImpl> CICXOrderView::GetICXSubmi
 {
     auto submitdfchtlc = ReadBy<ICXSubmitDFCHTLCCreationTx,CICXSubmitDFCHTLCImpl>(txid);
     if (submitdfchtlc)
-        return MakeUnique<CICXSubmitDFCHTLCImpl>(*submitdfchtlc);
+        return std::make_unique<CICXSubmitDFCHTLCImpl>(*submitdfchtlc);
     return {};
 }
 
@@ -292,7 +292,7 @@ std::unique_ptr<CICXOrderView::CICXSubmitEXTHTLCImpl> CICXOrderView::GetICXSubmi
 {
     auto submitexthtlc = ReadBy<ICXSubmitEXTHTLCCreationTx,CICXSubmitEXTHTLCImpl>(txid);
     if (submitexthtlc)
-        return MakeUnique<CICXSubmitEXTHTLCImpl>(*submitexthtlc);
+        return std::make_unique<CICXSubmitEXTHTLCImpl>(*submitexthtlc);
     return {};
 }
 
@@ -370,7 +370,7 @@ std::unique_ptr<CICXOrderView::CICXClaimDFCHTLCImpl> CICXOrderView::GetICXClaimD
 {
     auto claimdfchtlc = ReadBy<ICXClaimDFCHTLCCreationTx,CICXClaimDFCHTLCImpl>(txid);
     if (claimdfchtlc)
-        return MakeUnique<CICXClaimDFCHTLCImpl>(*claimdfchtlc);
+        return std::make_unique<CICXClaimDFCHTLCImpl>(*claimdfchtlc);
     return {};
 }
 
@@ -398,7 +398,7 @@ std::unique_ptr<CICXOrderView::CICXCloseOrderImpl> CICXOrderView::GetICXCloseOrd
 {
     auto closeorderImpl = ReadBy<ICXCloseOrderCreationTx, CICXCloseOrderImpl>(txid);
     if (closeorderImpl)
-        return MakeUnique<CICXCloseOrderImpl>(*closeorderImpl);
+        return std::make_unique<CICXCloseOrderImpl>(*closeorderImpl);
     return {};
 }
 
@@ -417,7 +417,7 @@ std::unique_ptr<CICXOrderView::CICXCloseOfferImpl> CICXOrderView::GetICXCloseOff
 {
     auto closeofferImpl = ReadBy<ICXCloseOfferCreationTx, CICXCloseOfferImpl>(txid);
     if (closeofferImpl)
-        return MakeUnique<CICXCloseOfferImpl>(*closeofferImpl);
+        return std::make_unique<CICXCloseOfferImpl>(*closeofferImpl);
     return {};
 }
 
diff --git a/src/masternodes/loan.cpp b/src/masternodes/loan.cpp
index 2de3e91937..d5036908f7 100644
--- a/src/masternodes/loan.cpp
+++ b/src/masternodes/loan.cpp
@@ -6,7 +6,7 @@ std::unique_ptr<CLoanView::CLoanSetCollateralTokenImpl> CLoanView::GetLoanCollat
 {
     auto collToken = ReadBy<LoanSetCollateralTokenCreationTx,CLoanSetCollateralTokenImpl>(txid);
     if (collToken)
-        return MakeUnique<CLoanSetCollateralTokenImpl>(*collToken);
+        return std::make_unique<CLoanSetCollateralTokenImpl>(*collToken);
     return {};
 }
 
@@ -66,7 +66,7 @@ std::unique_ptr<CLoanView::CLoanSetLoanTokenImpl> CLoanView::GetLoanTokenByID(DC
 {
     auto loanToken = ReadBy<LoanSetLoanTokenKey,CLoanSetLoanTokenImpl>(id);
     if (loanToken)
-        return MakeUnique<CLoanSetLoanTokenImpl>(*loanToken);
+        return std::make_unique<CLoanSetLoanTokenImpl>(*loanToken);
     return {};
 }
 
@@ -143,7 +143,7 @@ Res CLoanView::StoreDefaultLoanScheme(const std::string& loanSchemeID)
     return Res::Ok();
 }
 
-boost::optional<std::string> CLoanView::GetDefaultLoanScheme()
+std::optional<std::string> CLoanView::GetDefaultLoanScheme()
 {
     std::string loanSchemeID;
     if (Read(DefaultLoanSchemeKey::prefix(), loanSchemeID)) {
@@ -153,12 +153,12 @@ boost::optional<std::string> CLoanView::GetDefaultLoanScheme()
     return {};
 }
 
-boost::optional<CLoanSchemeData> CLoanView::GetLoanScheme(const std::string& loanSchemeID)
+std::optional<CLoanSchemeData> CLoanView::GetLoanScheme(const std::string& loanSchemeID)
 {
     return ReadBy<LoanSchemeKey, CLoanSchemeData>(loanSchemeID);
 }
 
-boost::optional<uint64_t> CLoanView::GetDestroyLoanScheme(const std::string& loanSchemeID)
+std::optional<uint64_t> CLoanView::GetDestroyLoanScheme(const std::string& loanSchemeID)
 {
     return ReadBy<DestroyLoanSchemeKey, uint64_t>(loanSchemeID);
 }
@@ -195,7 +195,7 @@ void CLoanView::EraseDelayedDestroyScheme(const std::string& loanSchemeID)
     EraseBy<DestroyLoanSchemeKey>(loanSchemeID);
 }
 
-boost::optional<CInterestRate> CLoanView::GetInterestRate(const CVaultId& vaultId, DCT_ID id)
+std::optional<CInterestRate> CLoanView::GetInterestRate(const CVaultId& vaultId, DCT_ID id)
 {
     return ReadBy<LoanInterestByVault, CInterestRate>(std::make_pair(vaultId, id));
 }
@@ -327,7 +327,7 @@ Res CLoanView::SubLoanToken(const CVaultId& vaultId, CTokenAmount amount)
     return Res::Ok();
 }
 
-boost::optional<CBalances> CLoanView::GetLoanTokens(const CVaultId& vaultId)
+std::optional<CBalances> CLoanView::GetLoanTokens(const CVaultId& vaultId)
 {
     return ReadBy<LoanTokenAmount, CBalances>(vaultId);
 }
diff --git a/src/masternodes/loan.h b/src/masternodes/loan.h
index 7301f85b54..9b70772798 100644
--- a/src/masternodes/loan.h
+++ b/src/masternodes/loan.h
@@ -279,22 +279,22 @@ class CLoanView : public virtual CStorageView {
     Res EraseLoanScheme(const std::string& loanSchemeID);
     void EraseDelayedLoanScheme(const std::string& loanSchemeID, uint64_t height);
     void EraseDelayedDestroyScheme(const std::string& loanSchemeID);
-    boost::optional<std::string> GetDefaultLoanScheme();
-    boost::optional<CLoanSchemeData> GetLoanScheme(const std::string& loanSchemeID);
-    boost::optional<uint64_t> GetDestroyLoanScheme(const std::string& loanSchemeID);
+    std::optional<std::string> GetDefaultLoanScheme();
+    std::optional<CLoanSchemeData> GetLoanScheme(const std::string& loanSchemeID);
+    std::optional<uint64_t> GetDestroyLoanScheme(const std::string& loanSchemeID);
     void ForEachLoanScheme(std::function<bool (const std::string&, const CLoanSchemeData&)> callback);
     void ForEachDelayedLoanScheme(std::function<bool (const std::pair<std::string, uint64_t>&, const CLoanSchemeMessage&)> callback);
     void ForEachDelayedDestroyScheme(std::function<bool (const std::string&, const uint64_t&)> callback);
 
     Res DeleteInterest(const CVaultId& vaultId);
-    boost::optional<CInterestRate> GetInterestRate(const CVaultId& loanSchemeID, DCT_ID id);
+    std::optional<CInterestRate> GetInterestRate(const CVaultId& loanSchemeID, DCT_ID id);
     Res StoreInterest(uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, DCT_ID id, CAmount loanIncreased);
     Res EraseInterest(uint32_t height, const CVaultId& vaultId, const std::string& loanSchemeID, DCT_ID id, CAmount loanDecreased, CAmount interestDecreased);
     void ForEachVaultInterest(std::function<bool(const CVaultId&, DCT_ID, CInterestRate)> callback, const CVaultId& vaultId = uint256(), DCT_ID id = {0});
 
     Res AddLoanToken(const CVaultId& vaultId, CTokenAmount amount);
     Res SubLoanToken(const CVaultId& vaultId, CTokenAmount amount);
-    boost::optional<CBalances> GetLoanTokens(const CVaultId& vaultId);
+    std::optional<CBalances> GetLoanTokens(const CVaultId& vaultId);
     void ForEachLoanToken(std::function<bool(const CVaultId&, const CBalances&)> callback);
 
     Res SetLoanLiquidationPenalty(CAmount penalty);
diff --git a/src/masternodes/masternodes.cpp b/src/masternodes/masternodes.cpp
index c911937ab0..f09c2decd3 100644
--- a/src/masternodes/masternodes.cpp
+++ b/src/masternodes/masternodes.cpp
@@ -190,17 +190,17 @@ bool operator!=(CMasternode const & a, CMasternode const & b)
 /*
  *  CMasternodesView
  */
-boost::optional<CMasternode> CMasternodesView::GetMasternode(const uint256 & id) const
+std::optional<CMasternode> CMasternodesView::GetMasternode(const uint256 & id) const
 {
     return ReadBy<ID, CMasternode>(id);
 }
 
-boost::optional<uint256> CMasternodesView::GetMasternodeIdByOperator(const CKeyID & id) const
+std::optional<uint256> CMasternodesView::GetMasternodeIdByOperator(const CKeyID & id) const
 {
     return ReadBy<Operator, uint256>(id);
 }
 
-boost::optional<uint256> CMasternodesView::GetMasternodeIdByOwner(const CKeyID & id) const
+std::optional<uint256> CMasternodesView::GetMasternodeIdByOwner(const CKeyID & id) const
 {
     return ReadBy<Owner, uint256>(id);
 }
@@ -226,13 +226,13 @@ void CMasternodesView::DecrementMintedBy(const uint256& nodeId)
     WriteBy<ID>(nodeId, *node);
 }
 
-boost::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOperator() const
+std::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOperator() const
 {
     auto const operators = gArgs.GetArgs("-masternode_operator");
     for(auto const & key : operators) {
         CTxDestination const dest = DecodeDestination(key);
-        CKeyID const authAddress = dest.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&dest)) :
-                                   dest.which() == WitV0KeyHashType ? CKeyID(*boost::get<WitnessV0KeyHash>(&dest)) : CKeyID();
+        CKeyID const authAddress = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) :
+                                   dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID();
         if (!authAddress.IsNull()) {
             if (auto nodeId = GetMasternodeIdByOperator(authAddress)) {
                 return std::make_pair(authAddress, *nodeId);
@@ -248,8 +248,8 @@ std::set<std::pair<CKeyID, uint256>> CMasternodesView::GetOperatorsMulti() const
     std::set<std::pair<CKeyID, uint256>> operatorPairs;
     for(auto const & key : operators) {
         CTxDestination const dest = DecodeDestination(key);
-        CKeyID const authAddress = dest.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&dest)) :
-                                   dest.which() == WitV0KeyHashType ? CKeyID(*boost::get<WitnessV0KeyHash>(&dest)) : CKeyID();
+        CKeyID const authAddress = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) :
+                                   dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID();
         if (!authAddress.IsNull()) {
             if (auto nodeId = GetMasternodeIdByOperator(authAddress)) {
                 operatorPairs.insert(std::make_pair(authAddress, *nodeId));
@@ -260,10 +260,10 @@ std::set<std::pair<CKeyID, uint256>> CMasternodesView::GetOperatorsMulti() const
     return operatorPairs;
 }
 
-boost::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOwner() const
+std::optional<std::pair<CKeyID, uint256> > CMasternodesView::AmIOwner() const
 {
     CTxDestination dest = DecodeDestination(gArgs.GetArg("-masternode_owner", ""));
-    CKeyID const authAddress = dest.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&dest)) : (dest.which() == WitV0KeyHashType ? CKeyID(*boost::get<WitnessV0KeyHash>(&dest)) : CKeyID());
+    CKeyID const authAddress = dest.index() == PKHashType ? CKeyID(std::get<PKHash>(dest)) : (dest.index() == WitV0KeyHashType ? CKeyID(std::get<WitnessV0KeyHash>(dest)) : CKeyID());
     if (!authAddress.IsNull()) {
         auto nodeId = GetMasternodeIdByOwner(authAddress);
         if (nodeId)
@@ -402,7 +402,7 @@ void CMasternodesView::SetMasternodeLastBlockTime(const CKeyID & minter, const u
     WriteBy<Staker>(MNBlockTimeKey{*nodeId, blockHeight}, time);
 }
 
-boost::optional<int64_t> CMasternodesView::GetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t height)
+std::optional<int64_t> CMasternodesView::GetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t height)
 {
     auto nodeId = GetMasternodeIdByOperator(minter);
     assert(nodeId);
@@ -544,7 +544,7 @@ uint16_t CMasternodesView::GetTimelock(const uint256& nodeId, const CMasternode&
 std::vector<int64_t> CMasternodesView::GetBlockTimes(const CKeyID& keyID, const uint32_t blockHeight, const int32_t creationHeight, const uint16_t timelock)
 {
     // Get last block time for non-subnode staking
-    boost::optional<int64_t> stakerBlockTime = GetMasternodeLastBlockTime(keyID, blockHeight);
+    std::optional<int64_t> stakerBlockTime = GetMasternodeLastBlockTime(keyID, blockHeight);
 
     // Get times for sub nodes, defaults to {0, 0, 0, 0} for MNs created before EunosPayaHeight
     std::vector<int64_t> subNodesBlockTime = GetSubNodesBlockTime(keyID, blockHeight);
@@ -649,14 +649,14 @@ void CTeamView::SetAnchorTeams(const CTeam& authTeam, const CTeam& confirmTeam,
     }
 }
 
-boost::optional<CTeamView::CTeam> CTeamView::GetAuthTeam(int height) const
+std::optional<CTeamView::CTeam> CTeamView::GetAuthTeam(int height) const
 {
     height -= height % Params().GetConsensus().mn.anchoringTeamChange;
 
     return ReadBy<AuthTeam, CTeam>(height);
 }
 
-boost::optional<CTeamView::CTeam> CTeamView::GetConfirmTeam(int height) const
+std::optional<CTeamView::CTeam> CTeamView::GetConfirmTeam(int height) const
 {
     height -= height % Params().GetConsensus().mn.anchoringTeamChange;
 
@@ -666,7 +666,7 @@ boost::optional<CTeamView::CTeam> CTeamView::GetConfirmTeam(int height) const
 /*
  *  CAnchorRewardsView
  */
-boost::optional<CAnchorRewardsView::RewardTxHash> CAnchorRewardsView::GetRewardForAnchor(const CAnchorRewardsView::AnchorTxHash & btcTxHash) const
+std::optional<CAnchorRewardsView::RewardTxHash> CAnchorRewardsView::GetRewardForAnchor(const CAnchorRewardsView::AnchorTxHash & btcTxHash) const
 {
     return ReadBy<BtcTx, RewardTxHash>(btcTxHash);
 }
@@ -987,7 +987,7 @@ Res CCustomCSView::PopulateLoansData(CCollateralLoans& result, CVaultId const& v
         if (!priceResult)
             return std::move(priceResult);
 
-        auto price = priceResult.val.get();
+        auto price = priceResult.val.value();
 
         LogPrint(BCLog::LOAN,"\t\t%s()->for_loans->%s->", __func__, token->symbol); /* Continued */
 
@@ -1023,7 +1023,7 @@ Res CCustomCSView::PopulateCollateralData(CCollateralLoans& result, CVaultId con
         if (!priceResult)
             return std::move(priceResult);
 
-        auto price = priceResult.val.get();
+        auto price = priceResult.val.value();
 
         auto amountInCurrency = MultiplyAmounts(price, tokenAmount);
         if (price > COIN && amountInCurrency < tokenAmount)
diff --git a/src/masternodes/masternodes.h b/src/masternodes/masternodes.h
index 33bef92061..5bf6849b4d 100644
--- a/src/masternodes/masternodes.h
+++ b/src/masternodes/masternodes.h
@@ -29,8 +29,6 @@
 #include <set>
 #include <stdint.h>
 
-#include <boost/optional.hpp>
-
 class CBlockIndex;
 class CTransaction;
 
@@ -185,16 +183,16 @@ class CMasternodesView : public virtual CStorageView
 public:
 //    CMasternodesView() = default;
 
-    boost::optional<CMasternode> GetMasternode(uint256 const & id) const;
-    boost::optional<uint256> GetMasternodeIdByOperator(CKeyID const & id) const;
-    boost::optional<uint256> GetMasternodeIdByOwner(CKeyID const & id) const;
+    std::optional<CMasternode> GetMasternode(uint256 const & id) const;
+    std::optional<uint256> GetMasternodeIdByOperator(CKeyID const & id) const;
+    std::optional<uint256> GetMasternodeIdByOwner(CKeyID const & id) const;
     void ForEachMasternode(std::function<bool(uint256 const &, CLazySerialize<CMasternode>)> callback, uint256 const & start = uint256());
 
     void IncrementMintedBy(const uint256& nodeId);
     void DecrementMintedBy(const uint256& nodeId);
 
-    boost::optional<std::pair<CKeyID, uint256>> AmIOperator() const;
-    boost::optional<std::pair<CKeyID, uint256>> AmIOwner() const;
+    std::optional<std::pair<CKeyID, uint256>> AmIOperator() const;
+    std::optional<std::pair<CKeyID, uint256>> AmIOwner() const;
 
     // Multiple operator support
     std::set<std::pair<CKeyID, uint256>> GetOperatorsMulti() const;
@@ -212,7 +210,7 @@ class CMasternodesView : public virtual CStorageView
 
     // Non-subnode block times
     void SetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t &blockHeight, const int64_t &time);
-    boost::optional<int64_t> GetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t height);
+    std::optional<int64_t> GetMasternodeLastBlockTime(const CKeyID & minter, const uint32_t height);
     void EraseMasternodeLastBlockTime(const uint256 &minter, const uint32_t& blockHeight);
     void ForEachMinterNode(std::function<bool(MNBlockTimeKey const &, CLazySerialize<int64_t>)> callback, MNBlockTimeKey const & start = {});
 
@@ -264,8 +262,8 @@ class CTeamView : public virtual CStorageView
     void SetAnchorTeams(CTeam const & authTeam, CTeam const & confirmTeam, const int height);
 
     CTeam GetCurrentTeam() const;
-    boost::optional<CTeam> GetAuthTeam(int height) const;
-    boost::optional<CTeam> GetConfirmTeam(int height) const;
+    std::optional<CTeam> GetAuthTeam(int height) const;
+    std::optional<CTeam> GetConfirmTeam(int height) const;
 
     struct AuthTeam     { static constexpr uint8_t prefix() { return 'v'; } };
     struct ConfirmTeam  { static constexpr uint8_t prefix() { return 'V'; } };
@@ -278,7 +276,7 @@ class CAnchorRewardsView : public virtual CStorageView
     using RewardTxHash = uint256;
     using AnchorTxHash = uint256;
 
-    boost::optional<RewardTxHash> GetRewardForAnchor(AnchorTxHash const &btcTxHash) const;
+    std::optional<RewardTxHash> GetRewardForAnchor(AnchorTxHash const &btcTxHash) const;
 
     void AddRewardForAnchor(AnchorTxHash const &btcTxHash, RewardTxHash const & rewardTxHash);
     void RemoveRewardForAnchor(AnchorTxHash const &btcTxHash);
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 9dcd377c78..6c18c89ff9 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -162,7 +162,7 @@ CCustomTxMessage customTypeToMessage(CustomTxType txType) {
 
 extern std::string ScriptToString(CScript const& script);
 
-class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
+class CCustomMetadataParseVisitor
 {
     uint32_t height;
     const Consensus::Params& consensus;
@@ -528,7 +528,7 @@ class CCustomMetadataParseVisitor : public boost::static_visitor<Res>
     }
 };
 
-class CCustomTxVisitor : public boost::static_visitor<Res>
+class CCustomTxVisitor
 {
 protected:
     uint32_t height;
@@ -874,12 +874,12 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
         CMasternode node;
         CTxDestination dest;
         if (ExtractDestination(tx.vout[1].scriptPubKey, dest)) {
-            if (dest.which() == PKHashType) {
+            if (dest.index() == PKHashType) {
                 node.ownerType = 1;
-                node.ownerAuthAddress = CKeyID(*boost::get<PKHash>(&dest));
-            } else if (dest.which() == WitV0KeyHashType) {
+                node.ownerAuthAddress = CKeyID(std::get<PKHash>(dest));
+            } else if (dest.index() == WitV0KeyHashType) {
                 node.ownerType = 4;
-                node.ownerAuthAddress = CKeyID(*boost::get<WitnessV0KeyHash>(&dest));
+                node.ownerAuthAddress = CKeyID(std::get<WitnessV0KeyHash>(dest));
             }
         }
         node.creationHeight = height;
@@ -1226,7 +1226,7 @@ class CCustomTxApplyVisitor : public CCustomTxVisitor
             return Res::Err("tx must have at least one input from account owner");
         }
 
-        CPoolPair& pool = pair.get();
+        CPoolPair& pool = pair.value();
 
         // subtract liq.balance BEFORE RemoveLiquidity call to check balance correctness
         {
@@ -2981,7 +2981,7 @@ class CCustomTxRevertVisitor : public CCustomTxVisitor
 
 Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, const std::vector<unsigned char>& metadata, CCustomTxMessage& txMessage) {
     try {
-        return boost::apply_visitor(CCustomMetadataParseVisitor(height, consensus, metadata), txMessage);
+        return std::visit(CCustomMetadataParseVisitor(height, consensus, metadata), txMessage);
     } catch (const std::exception& e) {
         return Res::Err(e.what());
     } catch (...) {
@@ -2991,8 +2991,8 @@ Res CustomMetadataParse(uint32_t height, const Consensus::Params& consensus, con
 
 Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage, uint64_t time) {
     try {
-        return boost::apply_visitor(CCustomTxApplyVisitor(tx, height, coins, mnview, consensus, time), txMessage);
-    } catch (const std::exception& e) {
+        return std::visit(CCustomTxApplyVisitor(tx, height, coins, mnview, consensus, time), txMessage);
+    } catch (const std::bad_variant_access& e) {
         return Res::Err(e.what());
     } catch (...) {
         return Res::Err("unexpected error");
@@ -3001,8 +3001,8 @@ Res CustomTxVisit(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTr
 
 Res CustomTxRevert(CCustomCSView& mnview, const CCoinsViewCache& coins, const CTransaction& tx, uint32_t height, const Consensus::Params& consensus, const CCustomTxMessage& txMessage) {
     try {
-        return boost::apply_visitor(CCustomTxRevertVisitor(tx, height, coins, mnview, consensus), txMessage);
-    } catch (const std::exception& e) {
+        return std::visit(CCustomTxRevertVisitor(tx, height, coins, mnview, consensus), txMessage);
+    } catch (const std::bad_variant_access& e) {
         return Res::Err(e.what());
     } catch (...) {
         return Res::Err("unexpected error");
@@ -3376,7 +3376,7 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs) {
 
     // Single swap if no pool IDs provided
     auto poolPrice = POOLPRICE_MAX;
-    boost::optional<std::pair<DCT_ID, CPoolPair> > poolPair;
+    std::optional<std::pair<DCT_ID, CPoolPair> > poolPair;
     if (poolIDs.empty()) {
         poolPair = view.GetPoolPair(obj.idTokenFrom, obj.idTokenTo);
         if (!poolPair) {
@@ -3401,7 +3401,7 @@ Res CPoolSwap::ExecuteSwap(CCustomCSView& view, std::vector<DCT_ID> poolIDs) {
         currentID = poolIDs[i];
 
         // Use single swap pool if already found
-        boost::optional<CPoolPair> pool;
+        std::optional<CPoolPair> pool;
         if (poolPair) {
             pool = poolPair->second;
         }
diff --git a/src/masternodes/mn_checks.h b/src/masternodes/mn_checks.h
index e1fdc7456c..416555735f 100644
--- a/src/masternodes/mn_checks.h
+++ b/src/masternodes/mn_checks.h
@@ -11,7 +11,7 @@
 #include <vector>
 #include <cstring>
 
-#include <boost/variant.hpp>
+#include <variant>
 
 class CBlock;
 class CTransaction;
@@ -315,7 +315,7 @@ struct CGovernanceHeightMessage {
 
 struct CCustomTxMessageNone {};
 
-typedef boost::variant<
+using CCustomTxMessage = std::variant<
     CCustomTxMessageNone,
     CCreateMasterNodeMessage,
     CResignMasterNodeMessage,
@@ -363,7 +363,7 @@ typedef boost::variant<
     CLoanTakeLoanMessage,
     CLoanPaybackLoanMessage,
     CAuctionBidMessage
-> CCustomTxMessage;
+>;
 
 CCustomTxMessage customTypeToMessage(CustomTxType txType);
 bool IsMempooledCustomTxCreate(const CTxMemPool& pool, const uint256& txid);
@@ -422,7 +422,7 @@ inline bool IsMintTokenTx(const CTransaction& tx)
     return GuessCustomTxType(tx, metadata) == CustomTxType::MintToken;
 }
 
-inline boost::optional<std::vector<unsigned char>> GetAccountToUtxosMetadata(const CTransaction & tx)
+inline std::optional<std::vector<unsigned char>> GetAccountToUtxosMetadata(const CTransaction & tx)
 {
     std::vector<unsigned char> metadata;
     if (GuessCustomTxType(tx, metadata) == CustomTxType::AccountToUtxos) {
@@ -431,7 +431,7 @@ inline boost::optional<std::vector<unsigned char>> GetAccountToUtxosMetadata(con
     return {};
 }
 
-inline boost::optional<CAccountToUtxosMessage> GetAccountToUtxosMsg(const CTransaction & tx)
+inline std::optional<CAccountToUtxosMessage> GetAccountToUtxosMsg(const CTransaction & tx)
 {
     const auto metadata = GetAccountToUtxosMetadata(tx);
     if (metadata) {
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
index e6652b3536..950dcbe625 100644
--- a/src/masternodes/mn_rpc.cpp
+++ b/src/masternodes/mn_rpc.cpp
@@ -268,7 +268,7 @@ static std::vector<CTxIn> GetInputs(UniValue const& inputs) {
     return vin;
 }
 
-boost::optional<CScript> AmIFounder(CWallet* const pwallet) {
+std::optional<CScript> AmIFounder(CWallet* const pwallet) {
     for(auto const & script : Params().GetConsensus().foundationMembers) {
         if(IsMineCached(*pwallet, script) == ISMINE_SPENDABLE)
             return { script };
@@ -276,7 +276,7 @@ boost::optional<CScript> AmIFounder(CWallet* const pwallet) {
     return {};
 }
 
-static boost::optional<CTxIn> GetAuthInputOnly(CWalletCoinsUnlocker& pwallet, CTxDestination const& auth) {
+static std::optional<CTxIn> GetAuthInputOnly(CWalletCoinsUnlocker& pwallet, CTxDestination const& auth) {
 
     std::vector<COutput> vecOutputs;
     CCoinControl cctl;
@@ -344,7 +344,7 @@ static CTransactionRef CreateAuthTx(CWalletCoinsUnlocker& pwallet, std::set<CScr
     return fund(mtx, pwallet, {}, &coinControl), sign(mtx, pwallet, {});
 }
 
-static boost::optional<CTxIn> GetAnyFoundationAuthInput(CWalletCoinsUnlocker& pwallet) {
+static std::optional<CTxIn> GetAnyFoundationAuthInput(CWalletCoinsUnlocker& pwallet) {
     for (auto const & founderScript : Params().GetConsensus().foundationMembers) {
         if (IsMineCached(*pwallet, founderScript) == ISMINE_SPENDABLE) {
             CTxDestination destination;
@@ -377,7 +377,7 @@ std::vector<CTxIn> GetAuthInputsSmart(CWalletCoinsUnlocker& pwallet, int32_t txV
         }
         auto authInput = GetAuthInputOnly(pwallet, destination);
         if (authInput) {
-            result.push_back(authInput.get());
+            result.push_back(authInput.value());
         }
         else {
             notFoundYet.insert(auth);
@@ -392,13 +392,13 @@ std::vector<CTxIn> GetAuthInputsSmart(CWalletCoinsUnlocker& pwallet, int32_t txV
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Need foundation member authorization");
             }
         } else {
-            auths.insert(anyFounder.get());
+            auths.insert(anyFounder.value());
             auto authInput = GetAnyFoundationAuthInput(pwallet);
             if (authInput) {
-                result.push_back(authInput.get());
+                result.push_back(authInput.value());
             }
             else {
-                notFoundYet.insert(anyFounder.get());
+                notFoundYet.insert(anyFounder.value());
             }
         }
     }
diff --git a/src/masternodes/poolpairs.cpp b/src/masternodes/poolpairs.cpp
index de555e1a62..361701cd05 100644
--- a/src/masternodes/poolpairs.cpp
+++ b/src/masternodes/poolpairs.cpp
@@ -123,7 +123,7 @@ Res CPoolPairView::UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool s
         return Res::Err("Pool with poolId %s does not exist", poolId.ToString());
     }
 
-    CPoolPair & pool = poolPair.get();
+    CPoolPair & pool = poolPair.value();
 
     if (pool.status != status) {
         pool.status = status;
@@ -157,7 +157,7 @@ Res CPoolPairView::UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool s
     return Res::Ok();
 }
 
-boost::optional<CPoolPair> CPoolPairView::GetPoolPair(const DCT_ID &poolId) const
+std::optional<CPoolPair> CPoolPairView::GetPoolPair(const DCT_ID &poolId) const
 {
     auto pool = ReadBy<ByID, CPoolPair>(poolId);
     if (!pool) {
@@ -184,7 +184,7 @@ boost::optional<CPoolPair> CPoolPairView::GetPoolPair(const DCT_ID &poolId) cons
     return pool;
 }
 
-boost::optional<std::pair<DCT_ID, CPoolPair> > CPoolPairView::GetPoolPair(const DCT_ID &tokenA, const DCT_ID &tokenB) const
+std::optional<std::pair<DCT_ID, CPoolPair> > CPoolPairView::GetPoolPair(const DCT_ID &tokenA, const DCT_ID &tokenB) const
 {
     DCT_ID poolId;
     ByPairKey key {tokenA, tokenB};
@@ -482,7 +482,7 @@ std::pair<CAmount, CAmount> CPoolPairView::UpdatePoolRewards(std::function<CToke
 
         CAmount distributedFeeA = 0;
         CAmount distributedFeeB = 0;
-        boost::optional<CScript> ownerAddress;
+        std::optional<CScript> ownerAddress;
 
         PoolHeightKey poolKey = {poolId, uint32_t(nHeight)};
 
@@ -617,7 +617,7 @@ Res CPoolPairView::DelShare(DCT_ID const & poolId, CScript const & provider) {
     return Res::Ok();
 }
 
-boost::optional<uint32_t> CPoolPairView::GetShare(DCT_ID const & poolId, CScript const & provider) {
+std::optional<uint32_t> CPoolPairView::GetShare(DCT_ID const & poolId, CScript const & provider) {
     return ReadBy<ByShare, uint32_t>(PoolShareKey{poolId, provider});
 }
 
diff --git a/src/masternodes/poolpairs.h b/src/masternodes/poolpairs.h
index 396e9ad852..c51f879e62 100644
--- a/src/masternodes/poolpairs.h
+++ b/src/masternodes/poolpairs.h
@@ -215,8 +215,8 @@ class CPoolPairView : public virtual CStorageView
     Res SetPoolPair(const DCT_ID &poolId, uint32_t height, CPoolPair const & pool);
     Res UpdatePoolPair(DCT_ID const & poolId, uint32_t height, bool status, CAmount const & commission, CScript const & ownerAddress, CBalances const & rewards);
 
-    boost::optional<CPoolPair> GetPoolPair(const DCT_ID &poolId) const;
-    boost::optional<std::pair<DCT_ID, CPoolPair> > GetPoolPair(DCT_ID const & tokenA, DCT_ID const & tokenB) const;
+    std::optional<CPoolPair> GetPoolPair(const DCT_ID &poolId) const;
+    std::optional<std::pair<DCT_ID, CPoolPair> > GetPoolPair(DCT_ID const & tokenA, DCT_ID const & tokenB) const;
 
     void ForEachPoolId(std::function<bool(DCT_ID const &)> callback, DCT_ID const & start = DCT_ID{0});
     void ForEachPoolPair(std::function<bool(DCT_ID const &, CPoolPair)> callback, DCT_ID const & start = DCT_ID{0});
@@ -225,7 +225,7 @@ class CPoolPairView : public virtual CStorageView
     Res SetShare(DCT_ID const & poolId, CScript const & provider, uint32_t height);
     Res DelShare(DCT_ID const & poolId, CScript const & provider);
 
-    boost::optional<uint32_t> GetShare(DCT_ID const & poolId, CScript const & provider);
+    std::optional<uint32_t> GetShare(DCT_ID const & poolId, CScript const & provider);
 
     void CalculatePoolRewards(DCT_ID const & poolId, std::function<CAmount()> onLiquidity, uint32_t begin, uint32_t end, std::function<void(RewardType, CTokenAmount, uint32_t)> onReward);
 
diff --git a/src/masternodes/res.h b/src/masternodes/res.h
index 3ea6a5221e..911069c2d3 100644
--- a/src/masternodes/res.h
+++ b/src/masternodes/res.h
@@ -1,9 +1,9 @@
 #ifndef DEFI_MASTERNODES_RES_H
 #define DEFI_MASTERNODES_RES_H
 
+#include <optional>
 #include <string>
 #include <tinyformat.h>
-#include <boost/optional.hpp>
 
 struct Res
 {
@@ -62,7 +62,7 @@ struct Res
 template <typename T>
 struct ResVal : public Res
 {
-    boost::optional<T> val{};
+    std::optional<T> val{};
 
     ResVal() = delete;
 
diff --git a/src/masternodes/rpc_accounts.cpp b/src/masternodes/rpc_accounts.cpp
index 86e49cac26..2ce0d532e7 100644
--- a/src/masternodes/rpc_accounts.cpp
+++ b/src/masternodes/rpc_accounts.cpp
@@ -170,7 +170,7 @@ static void searchInWallet(CWallet const * pwallet,
             if (!IsValidDestination(sent.destination)) {
                 continue;
             }
-            if (IsValidDestination(destination) && destination != sent.destination) {
+            if (IsValidDestination(destination) && account != GetScriptForDestination(sent.destination)) {
                 continue;
             }
             sent.amount = -sent.amount;
@@ -183,7 +183,7 @@ static void searchInWallet(CWallet const * pwallet,
             if (!IsValidDestination(recv.destination)) {
                 continue;
             }
-            if (IsValidDestination(destination) && destination != recv.destination) {
+            if (IsValidDestination(destination) && account != GetScriptForDestination(recv.destination)) {
                 continue;
             }
             if (!txEntry(recv, index, pwtx)) {
@@ -1086,7 +1086,7 @@ UniValue listaccounthistory(const JSONRPCRequest& request) {
 
         std::unique_ptr<CScopeAccountReverter> reverter;
         if (!noRewards) {
-            reverter = MakeUnique<CScopeAccountReverter>(view, key.owner, valueLazy.get().diff);
+            reverter = std::make_unique<CScopeAccountReverter>(view, key.owner, valueLazy.get().diff);
         }
 
         bool accountRecord = true;
@@ -1468,7 +1468,7 @@ UniValue accounthistorycount(const JSONRPCRequest& request) {
 
         std::unique_ptr<CScopeAccountReverter> reverter;
         if (!noRewards) {
-            reverter = MakeUnique<CScopeAccountReverter>(view, key.owner, value.diff);
+            reverter = std::make_unique<CScopeAccountReverter>(view, key.owner, value.diff);
         }
 
         if (CustomTxType::None != txType && value.category != uint8_t(txType)) {
diff --git a/src/masternodes/rpc_customtx.cpp b/src/masternodes/rpc_customtx.cpp
index 86fac6a5c9..66225898bc 100644
--- a/src/masternodes/rpc_customtx.cpp
+++ b/src/masternodes/rpc_customtx.cpp
@@ -8,12 +8,9 @@
 #include <rpc/request.h>
 #include <univalue.h>
 
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/static_visitor.hpp>
-
 extern std::string ScriptToString(CScript const& script);
 
-class CCustomTxRpcVisitor : public boost::static_visitor<void>
+class CCustomTxRpcVisitor
 {
     uint32_t height;
     UniValue& rpcInfo;
@@ -450,7 +447,7 @@ Res RpcInfo(const CTransaction& tx, uint32_t height, CustomTxType& txType, UniVa
     auto res = CustomMetadataParse(height, Params().GetConsensus(), metadata, txMessage);
     if (res) {
         CCustomCSView mnview(*pcustomcsview);
-        boost::apply_visitor(CCustomTxRpcVisitor(tx, height, mnview, results), txMessage);
+        std::visit(CCustomTxRpcVisitor(tx, height, mnview, results), txMessage);
     }
     return res;
 }
diff --git a/src/masternodes/rpc_masternodes.cpp b/src/masternodes/rpc_masternodes.cpp
index fecd21dee7..1dca5d04b9 100644
--- a/src/masternodes/rpc_masternodes.cpp
+++ b/src/masternodes/rpc_masternodes.cpp
@@ -157,7 +157,7 @@ UniValue createmasternode(const JSONRPCRequest& request)
     }
 
     // check type here cause need operatorAuthKey. all other validation (for owner for ex.) in further apply/create
-    if (operatorDest.which() != 1 && operatorDest.which() != 4) {
+    if (operatorDest.index() != 1 && operatorDest.index() != 4) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "operatorAddress (" + operatorAddress + ") does not refer to a P2PKH or P2WPKH address");
     }
 
@@ -165,11 +165,11 @@ UniValue createmasternode(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Address (%s) is not owned by the wallet", EncodeDestination(ownerDest)));
     }
 
-    CKeyID const operatorAuthKey = operatorDest.which() == 1 ? CKeyID(*boost::get<PKHash>(&operatorDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest));
+    CKeyID const operatorAuthKey = operatorDest.index() == 1 ? CKeyID(std::get<PKHash>(operatorDest)) : CKeyID(std::get<WitnessV0KeyHash>(operatorDest));
 
     CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
     metadata << static_cast<unsigned char>(CustomTxType::CreateMasternode)
-             << static_cast<char>(operatorDest.which()) << operatorAuthKey;
+             << static_cast<char>(operatorDest.index()) << operatorAuthKey;
 
     if (eunosPaya) {
         metadata << timelock;
@@ -268,13 +268,13 @@ UniValue setforcedrewardaddress(const JSONRPCRequest& request)
 
     std::string rewardAddress = request.params[1].getValStr();
     CTxDestination rewardDest = DecodeDestination(rewardAddress);
-    if (rewardDest.which() != PKHashType && rewardDest.which() != WitV0KeyHashType) {
+    if (rewardDest.index() != PKHashType && rewardDest.index() != WitV0KeyHashType) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "rewardAddress (" + rewardAddress + ") does not refer to a P2PKH or P2WPKH address");
     }
 
-    CKeyID const rewardAuthKey = rewardDest.which() == PKHashType ?
-        CKeyID(*boost::get<PKHash>(&rewardDest)) :
-        CKeyID(*boost::get<WitnessV0KeyHash>(&rewardDest)
+    CKeyID const rewardAuthKey = rewardDest.index() == PKHashType ?
+        CKeyID(std::get<PKHash>(rewardDest)) :
+        CKeyID(std::get<WitnessV0KeyHash>(rewardDest)
     );
 
     const auto txVersion = GetTransactionVersion(targetHeight);
@@ -290,7 +290,7 @@ UniValue setforcedrewardaddress(const JSONRPCRequest& request)
         coinControl.destChange = ownerDest;
     }
 
-    CSetForcedRewardAddressMessage msg{nodeId, static_cast<char>(rewardDest.which()), rewardAuthKey};
+    CSetForcedRewardAddressMessage msg{nodeId, static_cast<char>(rewardDest.index()), rewardAuthKey};
 
     CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
     metadata << static_cast<unsigned char>(CustomTxType::SetForcedRewardAddress)
@@ -559,7 +559,7 @@ UniValue updatemasternode(const JSONRPCRequest& request)
     CTxDestination operatorDest = DecodeDestination(operatorAddress);
 
     // check type here cause need operatorAuthKey. all other validation (for owner for ex.) in further apply/create
-    if (operatorDest.which() != PKHashType && operatorDest.which() != WitV0KeyHashType) {
+    if (operatorDest.index() != PKHashType && operatorDest.index() != WitV0KeyHashType) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "operatorAddress (" + operatorAddress + ") does not refer to a P2PKH or P2WPKH address");
     }
 
@@ -576,12 +576,12 @@ UniValue updatemasternode(const JSONRPCRequest& request)
         coinControl.destChange = ownerDest;
     }
 
-    CKeyID const operatorAuthKey = operatorDest.which() == PKHashType ? CKeyID(*boost::get<PKHash>(&operatorDest)) : CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest));
+    CKeyID const operatorAuthKey = operatorDest.index() == PKHashType ? CKeyID(std::get<PKHash>(operatorDest)) : CKeyID(std::get<WitnessV0KeyHash>(operatorDest));
 
     CDataStream metadata(DfTxMarker, SER_NETWORK, PROTOCOL_VERSION);
     metadata << static_cast<unsigned char>(CustomTxType::UpdateMasternode)
              << nodeId
-             << static_cast<char>(operatorDest.which()) << operatorAuthKey;
+             << static_cast<char>(operatorDest.index()) << operatorAuthKey;
 
     CScript scriptMeta;
     scriptMeta << OP_RETURN << ToByteVector(metadata);
@@ -735,10 +735,10 @@ UniValue getmasternodeblocks(const JSONRPCRequest& request) {
         CKeyID ownerAddressID;
         auto ownerAddress = identifier["ownerAddress"].getValStr();
         auto ownerDest = DecodeDestination(ownerAddress);
-        if (ownerDest.which() == 1) {
-            ownerAddressID = CKeyID(*boost::get<PKHash>(&ownerDest));
-        } else if (ownerDest.which() == WitV0KeyHashType) {
-            ownerAddressID = CKeyID(*boost::get<WitnessV0KeyHash>(&ownerDest));
+        if (ownerDest.index() == 1) {
+            ownerAddressID = CKeyID(std::get<PKHash>(ownerDest));
+        } else if (ownerDest.index() == WitV0KeyHashType) {
+            ownerAddressID = CKeyID(std::get<WitnessV0KeyHash>(ownerDest));
         } else {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid P2PKH address");
         }
@@ -754,10 +754,10 @@ UniValue getmasternodeblocks(const JSONRPCRequest& request) {
         CKeyID operatorAddressID;
         auto operatorAddress = identifier["operatorAddress"].getValStr();
         auto operatorDest = DecodeDestination(operatorAddress);
-        if (operatorDest.which() == 1) {
-            operatorAddressID = CKeyID(*boost::get<PKHash>(&operatorDest));
-        } else if (operatorDest.which() == WitV0KeyHashType) {
-            operatorAddressID = CKeyID(*boost::get<WitnessV0KeyHash>(&operatorDest));
+        if (operatorDest.index() == 1) {
+            operatorAddressID = CKeyID(std::get<PKHash>(operatorDest));
+        } else if (operatorDest.index() == WitV0KeyHashType) {
+            operatorAddressID = CKeyID(std::get<WitnessV0KeyHash>(operatorDest));
         } else {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid P2PKH address");
         }
diff --git a/src/masternodes/rpc_oracles.cpp b/src/masternodes/rpc_oracles.cpp
index 7ed1d7a980..f4d11ff099 100644
--- a/src/masternodes/rpc_oracles.cpp
+++ b/src/masternodes/rpc_oracles.cpp
@@ -534,9 +534,8 @@ bool diffInHour(int64_t time1, int64_t time2) {
 }
 
 std::pair<int, int> GetFixedIntervalPriceBlocks(int currentHeight, const CCustomCSView &mnview){
-    auto FCHeight = Params().GetConsensus().FortCanningHeight;
     auto fixedBlocks = mnview.GetIntervalBlock();
-    auto nextPriceBlock = currentHeight + (fixedBlocks - ((currentHeight - FCHeight) % fixedBlocks));
+    auto nextPriceBlock = currentHeight + (fixedBlocks - ((currentHeight) % fixedBlocks));
     auto activePriceBlock = nextPriceBlock - fixedBlocks;
     return {activePriceBlock, nextPriceBlock};
 }
@@ -738,7 +737,7 @@ UniValue listlatestrawprices(const JSONRPCRequest &request) {
 
     RPCTypeCheck(request.params, {UniValue::VOBJ}, false);
 
-    boost::optional<CTokenCurrencyPair> tokenPair;
+    std::optional<CTokenCurrencyPair> tokenPair;
 
     // parse pagination
     COracleId start = {};
diff --git a/src/masternodes/rpc_tokens.cpp b/src/masternodes/rpc_tokens.cpp
index f41e72aeb6..a4aca9d915 100644
--- a/src/masternodes/rpc_tokens.cpp
+++ b/src/masternodes/rpc_tokens.cpp
@@ -75,7 +75,7 @@ UniValue createtoken(const JSONRPCRequest& request) {
 
     std::string collateralAddress = metaObj["collateralAddress"].getValStr();
     CTxDestination collateralDest = DecodeDestination(collateralAddress);
-    if (collateralDest.which() == 0) {
+    if (collateralDest.index() == 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "collateralAddress (" + collateralAddress + ") does not refer to any valid address");
     }
 
diff --git a/src/masternodes/tokens.cpp b/src/masternodes/tokens.cpp
index 7f4478e255..af6f195180 100644
--- a/src/masternodes/tokens.cpp
+++ b/src/masternodes/tokens.cpp
@@ -29,13 +29,13 @@ std::string trim_ws(std::string const & str)
 std::unique_ptr<CToken> CTokensView::GetToken(DCT_ID id) const
 {
     if (auto tokenImpl = ReadBy<ID, CTokenImpl>(id)) {
-        return MakeUnique<CTokenImpl>(*tokenImpl);
+        return std::make_unique<CTokenImpl>(*tokenImpl);
     }
 
     return {};
 }
 
-boost::optional<std::pair<DCT_ID, std::unique_ptr<CToken> > > CTokensView::GetToken(const std::string & symbolKey) const
+std::optional<std::pair<DCT_ID, std::unique_ptr<CToken> > > CTokensView::GetToken(const std::string & symbolKey) const
 {
     DCT_ID id;
     if (ReadBy<Symbol, std::string>(symbolKey, id)) {
@@ -44,7 +44,7 @@ boost::optional<std::pair<DCT_ID, std::unique_ptr<CToken> > > CTokensView::GetTo
     return {};
 }
 
-boost::optional<std::pair<DCT_ID, CTokensView::CTokenImpl> > CTokensView::GetTokenByCreationTx(const uint256 & txid) const
+std::optional<std::pair<DCT_ID, CTokensView::CTokenImpl> > CTokensView::GetTokenByCreationTx(const uint256 & txid) const
 {
     DCT_ID id;
     if (ReadBy<CreationTx, uint256>(txid, id)) {
@@ -71,7 +71,7 @@ std::unique_ptr<CToken> CTokensView::GetTokenGuessId(const std::string & str, DC
         auto pair = GetTokenByCreationTx(tx);
         if (pair) {
             id = pair->first;
-            return MakeUnique<CTokenImpl>(pair->second);
+            return std::make_unique<CTokenImpl>(pair->second);
         }
     } else {
         auto pair = GetToken(key);
@@ -305,7 +305,7 @@ DCT_ID CTokensView::DecrementLastDctId()
     return *lastDctId;
 }
 
-boost::optional<DCT_ID> CTokensView::ReadLastDctId() const
+std::optional<DCT_ID> CTokensView::ReadLastDctId() const
 {
     DCT_ID lastDctId{DCT_ID_START};
     if (Read(LastDctId::prefix(), lastDctId)) {
diff --git a/src/masternodes/tokens.h b/src/masternodes/tokens.h
index 69d7319480..d3a9a80257 100644
--- a/src/masternodes/tokens.h
+++ b/src/masternodes/tokens.h
@@ -143,9 +143,9 @@ class CTokensView : public virtual CStorageView
 
     using CTokenImpl = CTokenImplementation;
     std::unique_ptr<CToken> GetToken(DCT_ID id) const;
-    boost::optional<std::pair<DCT_ID, std::unique_ptr<CToken>>> GetToken(std::string const & symbol) const;
+    std::optional<std::pair<DCT_ID, std::unique_ptr<CToken>>> GetToken(std::string const & symbol) const;
     // the only possible type of token (with creationTx) is CTokenImpl
-    boost::optional<std::pair<DCT_ID, CTokenImpl>> GetTokenByCreationTx(uint256 const & txid) const;
+    std::optional<std::pair<DCT_ID, CTokenImpl>> GetTokenByCreationTx(uint256 const & txid) const;
     std::unique_ptr<CToken> GetTokenGuessId(const std::string & str, DCT_ID & id) const;
 
     void ForEachToken(std::function<bool(DCT_ID const &, CLazySerialize<CTokenImpl>)> callback, DCT_ID const & start = DCT_ID{0});
@@ -169,7 +169,7 @@ class CTokensView : public virtual CStorageView
     // have to incapsulate "last token id" related methods here
     DCT_ID IncrementLastDctId();
     DCT_ID DecrementLastDctId();
-    boost::optional<DCT_ID> ReadLastDctId() const;
+    std::optional<DCT_ID> ReadLastDctId() const;
 };
 
 #endif // DEFI_MASTERNODES_TOKENS_H
diff --git a/src/masternodes/undos.cpp b/src/masternodes/undos.cpp
index 08618aabc2..47bd1d9bfd 100644
--- a/src/masternodes/undos.cpp
+++ b/src/masternodes/undos.cpp
@@ -21,7 +21,7 @@ Res CUndosView::DelUndo(UndoKey const & key)
     return Res::Ok();
 }
 
-boost::optional<CUndo> CUndosView::GetUndo(UndoKey const & key) const
+std::optional<CUndo> CUndosView::GetUndo(UndoKey const & key) const
 {
     CUndo val;
     bool ok = ReadBy<ByUndoKey>(key, val);
diff --git a/src/masternodes/undos.h b/src/masternodes/undos.h
index 8788c5eddb..bf9ebe1f1c 100644
--- a/src/masternodes/undos.h
+++ b/src/masternodes/undos.h
@@ -13,7 +13,7 @@ class CUndosView : public virtual CStorageView {
 public:
     void ForEachUndo(std::function<bool(UndoKey const &, CLazySerialize<CUndo>)> callback, UndoKey const & start = {});
 
-    boost::optional<CUndo> GetUndo(UndoKey const & key) const;
+    std::optional<CUndo> GetUndo(UndoKey const & key) const;
     Res SetUndo(UndoKey const & key, CUndo const & undo);
     Res DelUndo(UndoKey const & key);
 
diff --git a/src/masternodes/vault.cpp b/src/masternodes/vault.cpp
index a1751ae078..7eb9fff3bc 100644
--- a/src/masternodes/vault.cpp
+++ b/src/masternodes/vault.cpp
@@ -35,7 +35,7 @@ Res CVaultView::EraseVault(const CVaultId& vaultId)
     return Res::Ok();
 }
 
-boost::optional<CVaultData> CVaultView::GetVault(const CVaultId& vaultId) const
+std::optional<CVaultData> CVaultView::GetVault(const CVaultId& vaultId) const
 {
     return ReadBy<VaultKey, CVaultData>(vaultId);
 }
@@ -94,7 +94,7 @@ Res CVaultView::SubVaultCollateral(const CVaultId& vaultId, CTokenAmount amount)
     return Res::Ok();
 }
 
-boost::optional<CBalances> CVaultView::GetVaultCollaterals(const CVaultId& vaultId)
+std::optional<CBalances> CVaultView::GetVaultCollaterals(const CVaultId& vaultId)
 {
     return ReadBy<CollateralKey, CBalances>(vaultId);
 }
@@ -127,7 +127,7 @@ Res CVaultView::EraseAuction(const CVaultId& vaultId, uint32_t height)
     return Res::Err("Auction for vault <%s> not found", vaultId.GetHex());
 }
 
-boost::optional<CAuctionData> CVaultView::GetAuction(const CVaultId& vaultId, uint32_t height)
+std::optional<CAuctionData> CVaultView::GetAuction(const CVaultId& vaultId, uint32_t height)
 {
     auto it = LowerBound<AuctionHeightKey>(CAuctionKey{vaultId, height});
     for (; it.Valid(); it.Next()) {
@@ -152,7 +152,7 @@ Res CVaultView::EraseAuctionBatch(const CVaultId& vaultId, uint32_t id)
     return Res::Ok();
 }
 
-boost::optional<CAuctionBatch> CVaultView::GetAuctionBatch(const CVaultId& vaultId, uint32_t id)
+std::optional<CAuctionBatch> CVaultView::GetAuctionBatch(const CVaultId& vaultId, uint32_t id)
 {
     return ReadBy<AuctionBatchKey, CAuctionBatch>(std::make_pair(vaultId, id));
 }
@@ -177,7 +177,7 @@ Res CVaultView::EraseAuctionBid(const CVaultId& vaultId, uint32_t id)
     return Res::Ok();
 }
 
-boost::optional<CVaultView::COwnerTokenAmount> CVaultView::GetAuctionBid(const CVaultId& vaultId, uint32_t id)
+std::optional<CVaultView::COwnerTokenAmount> CVaultView::GetAuctionBid(const CVaultId& vaultId, uint32_t id)
 {
     return ReadBy<AuctionBidKey, COwnerTokenAmount>(std::make_pair(vaultId, id));
 }
diff --git a/src/masternodes/vault.h b/src/masternodes/vault.h
index c6884c875b..becd32de48 100644
--- a/src/masternodes/vault.h
+++ b/src/masternodes/vault.h
@@ -155,27 +155,27 @@ class CVaultView : public virtual CStorageView
 public:
     Res StoreVault(const CVaultId&, const CVaultData&);
     Res EraseVault(const CVaultId&);
-    boost::optional<CVaultData> GetVault(const CVaultId&) const;
+    std::optional<CVaultData> GetVault(const CVaultId&) const;
     Res UpdateVault(const CVaultId& vaultId, const CVaultMessage& newVault);
     void ForEachVault(std::function<bool(const CVaultId&, const CVaultData&)> callback, const CVaultId& start = {}, const CScript& ownerAddress = {});
 
     Res AddVaultCollateral(const CVaultId& vaultId, CTokenAmount amount);
     Res SubVaultCollateral(const CVaultId& vaultId, CTokenAmount amount);
-    boost::optional<CBalances> GetVaultCollaterals(const CVaultId& vaultId);
+    std::optional<CBalances> GetVaultCollaterals(const CVaultId& vaultId);
     void ForEachVaultCollateral(std::function<bool(const CVaultId&, const CBalances&)> callback);
 
     Res StoreAuction(const CVaultId& vaultId, const CAuctionData& data);
     Res EraseAuction(const CVaultId& vaultId, uint32_t height);
-    boost::optional<CAuctionData> GetAuction(const CVaultId& vaultId, uint32_t height);
+    std::optional<CAuctionData> GetAuction(const CVaultId& vaultId, uint32_t height);
     Res StoreAuctionBatch(const CVaultId& vaultId, uint32_t id, const CAuctionBatch& batch);
     Res EraseAuctionBatch(const CVaultId& vaultId, uint32_t id);
-    boost::optional<CAuctionBatch> GetAuctionBatch(const CVaultId& vaultId, uint32_t id);
+    std::optional<CAuctionBatch> GetAuctionBatch(const CVaultId& vaultId, uint32_t id);
     void ForEachVaultAuction(std::function<bool(const CVaultId&, const CAuctionData&)> callback, uint32_t height, const CVaultId& vaultId = {});
 
     using COwnerTokenAmount = std::pair<CScript, CTokenAmount>;
     Res StoreAuctionBid(const CVaultId& vaultId, uint32_t id, COwnerTokenAmount amount);
     Res EraseAuctionBid(const CVaultId& vaultId, uint32_t id);
-    boost::optional<COwnerTokenAmount> GetAuctionBid(const CVaultId& vaultId, uint32_t id);
+    std::optional<COwnerTokenAmount> GetAuctionBid(const CVaultId& vaultId, uint32_t id);
 
     struct VaultKey         { static constexpr uint8_t prefix() { return 0x20; } };
     struct OwnerVaultKey    { static constexpr uint8_t prefix() { return 0x21; } };
diff --git a/src/miner.cpp b/src/miner.cpp
index 9587adea08..ef63f7b134 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -91,9 +91,6 @@ void BlockAssembler::resetBlock()
     nFees = 0;
 }
 
-Optional<int64_t> BlockAssembler::m_last_block_num_txs{nullopt};
-Optional<int64_t> BlockAssembler::m_last_block_weight{nullopt};
-
 std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn, int64_t blockTime)
 {
     int64_t nTimeStart = GetTimeMicros();
@@ -113,7 +110,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     LOCK2(cs_main, mempool.cs);
     // in fact, this may be redundant cause it was checked upthere in the miner
-    boost::optional<std::pair<CKeyID, uint256>> myIDs;
+    std::optional<std::pair<CKeyID, uint256>> myIDs;
     if (!blockTime) {
         myIDs = pcustomcsview->AmIOperator();
         if (!myIDs)
@@ -784,7 +781,7 @@ namespace pos {
             // Search backwards in time first
             if (currentTime > lastSearchTime) {
                 for (uint32_t t = 0; t < currentTime - lastSearchTime; ++t) {
-                    boost::this_thread::interruption_point();
+                    if (ShutdownRequested()) break;
 
                     blockTime = ((uint32_t)currentTime - t);
 
@@ -799,7 +796,7 @@ namespace pos {
                         break;
                     }
 
-                    boost::this_thread::yield(); // give a slot to other threads
+                    std::this_thread::yield(); // give a slot to other threads
                 }
             }
 
@@ -809,7 +806,7 @@ namespace pos {
 
                 // Search forwards in time
                 for (uint32_t t = 1; t <= futureTime - searchTime; ++t) {
-                    boost::this_thread::interruption_point();
+                    if (ShutdownRequested()) break;
 
                     blockTime = ((uint32_t)searchTime + t);
 
@@ -824,7 +821,7 @@ namespace pos {
                         break;
                     }
 
-                    boost::this_thread::yield(); // give a slot to other threads
+                    std::this_thread::yield(); // give a slot to other threads
                 }
             }
         }, blockHeight);
@@ -904,7 +901,7 @@ void ThreadStaker::operator()(std::vector<ThreadStaker::Args> args, CChainParams
 
     for (auto& arg : args) {
         while (true) {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) break;
 
             bool found = false;
             for (auto wallet : wallets) {
@@ -928,10 +925,10 @@ void ThreadStaker::operator()(std::vector<ThreadStaker::Args> args, CChainParams
     LogPrintf("ThreadStaker: started.\n");
 
     while (!args.empty()) {
-        boost::this_thread::interruption_point();
+        if (ShutdownRequested()) break;
 
         while (fImporting || fReindex) {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) break;
 
             LogPrintf("ThreadStaker: waiting reindex...\n");
 
@@ -942,7 +939,7 @@ void ThreadStaker::operator()(std::vector<ThreadStaker::Args> args, CChainParams
             const auto& arg = *it;
             const auto operatorName = arg.operatorID.GetHex();
 
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) break;
 
             pos::Staker staker;
 
diff --git a/src/miner.h b/src/miner.h
index b20cc9adf9..d17322cd67 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -6,7 +6,6 @@
 #ifndef DEFI_MINER_H
 #define DEFI_MINER_H
 
-#include <optional.h>
 #include <primitives/block.h>
 #include <key.h>
 #include <timedata.h>
@@ -14,6 +13,7 @@
 #include <validation.h>
 
 #include <memory>
+#include <optional>
 #include <stdint.h>
 
 #include <boost/multi_index_container.hpp>
@@ -166,8 +166,8 @@ class BlockAssembler
     /** Construct a new block template with coinbase to scriptPubKeyIn */
     std::unique_ptr<CBlockTemplate> CreateNewBlock(const CScript& scriptPubKeyIn, int64_t blockTime = 0);
 
-    static Optional<int64_t> m_last_block_num_txs;
-    static Optional<int64_t> m_last_block_weight;
+    inline static std::optional<int64_t> m_last_block_num_txs{};
+    inline static std::optional<int64_t> m_last_block_weight{};
 
 private:
     // utility functions
diff --git a/src/net.cpp b/src/net.cpp
index 2880d09942..291d2fb1e6 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -2231,11 +2231,11 @@ bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
 
     if (semOutbound == nullptr) {
         // initialize semaphore
-        semOutbound = MakeUnique<CSemaphore>(std::min((nMaxOutbound + nMaxFeeler), nMaxConnections));
+        semOutbound = std::make_unique<CSemaphore>(std::min((nMaxOutbound + nMaxFeeler), nMaxConnections));
     }
     if (semAddnode == nullptr) {
         // initialize semaphore
-        semAddnode = MakeUnique<CSemaphore>(nMaxAddnode);
+        semAddnode = std::make_unique<CSemaphore>(nMaxAddnode);
     }
 
     //
@@ -2636,7 +2636,7 @@ CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, int nMyStartingHeightIn
     addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
     hashContinue = uint256();
     filterInventoryKnown.reset();
-    pfilter = MakeUnique<CBloomFilter>();
+    pfilter = std::make_unique<CBloomFilter>();
 
     for (const std::string &msg : getAllNetMessageTypes())
         mapRecvBytesPerMsgCmd[msg] = 0;
diff --git a/src/node/coinstats.cpp b/src/node/coinstats.cpp
index 226110725c..ffb9723a99 100644
--- a/src/node/coinstats.cpp
+++ b/src/node/coinstats.cpp
@@ -7,7 +7,6 @@
 
 #include <amount.h>
 #include <coins.h>
-#include <chain.h>
 #include <hash.h>
 #include <serialize.h>
 #include <validation.h>
@@ -16,8 +15,6 @@
 
 #include <map>
 
-#include <boost/thread.hpp>
-
 
 static void ApplyStats(CCoinsStats &stats, CHashWriter& ss, const uint256& hash, const std::map<uint32_t, Coin>& outputs)
 {
@@ -38,7 +35,7 @@ static void ApplyStats(CCoinsStats &stats, CHashWriter& ss, const uint256& hash,
 }
 
 //! Calculate statistics about the unspent transaction output set
-bool GetUTXOStats(CCoinsView *view, CCoinsStats &stats)
+bool GetUTXOStats(CCoinsView* view, CCoinsStats& stats, const std::function<void()>& interruption_point)
 {
     std::unique_ptr<CCoinsViewCursor> pcursor(view->Cursor());
     assert(pcursor);
@@ -53,7 +50,7 @@ bool GetUTXOStats(CCoinsView *view, CCoinsStats &stats)
     uint256 prevkey;
     std::map<uint32_t, Coin> outputs;
     while (pcursor->Valid()) {
-        boost::this_thread::interruption_point();
+        interruption_point();
         COutPoint key;
         Coin coin;
         if (pcursor->GetKey(key) && pcursor->GetValue(coin)) {
diff --git a/src/node/coinstats.h b/src/node/coinstats.h
index 49f10464b2..7fef565f44 100644
--- a/src/node/coinstats.h
+++ b/src/node/coinstats.h
@@ -10,6 +10,7 @@
 #include <uint256.h>
 
 #include <cstdint>
+#include <functional>
 
 class CCoinsView;
 
@@ -28,6 +29,6 @@ struct CCoinsStats
 };
 
 //! Calculate statistics about the unspent transaction output set
-bool GetUTXOStats(CCoinsView* view, CCoinsStats& stats);
+bool GetUTXOStats(CCoinsView* view, CCoinsStats& stats, const std::function<void()>& interruption_point = {});
 
 #endif // DEFI_NODE_COINSTATS_H
diff --git a/src/node/psbt.h b/src/node/psbt.h
index 949ecdd283..5a8c44ff10 100644
--- a/src/node/psbt.h
+++ b/src/node/psbt.h
@@ -25,9 +25,9 @@ struct PSBTInputAnalysis {
  * Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
  */
 struct PSBTAnalysis {
-    Optional<size_t> estimated_vsize;      //!< Estimated weight of the transaction
-    Optional<CFeeRate> estimated_feerate;  //!< Estimated feerate (fee / weight) of the transaction
-    Optional<CAmount> fee;                 //!< Amount of fee being paid by the transaction
+    std::optional<size_t> estimated_vsize;      //!< Estimated weight of the transaction
+    std::optional<CFeeRate> estimated_feerate;  //!< Estimated feerate (fee / weight) of the transaction
+    std::optional<CAmount> fee;                 //!< Amount of fee being paid by the transaction
     std::vector<PSBTInputAnalysis> inputs; //!< More information about the individual inputs of the transaction
     PSBTRole next;                         //!< Which of the BIP 174 roles needs to handle the transaction next
 };
diff --git a/src/optional.h b/src/optional.h
deleted file mode 100644
index e17dd01288..0000000000
--- a/src/optional.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2017 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef DEFI_OPTIONAL_H
-#define DEFI_OPTIONAL_H
-
-#include <utility>
-
-#include <boost/optional.hpp>
-
-//! Substitute for C++17 std::optional
-template <typename T>
-using Optional = boost::optional<T>;
-
-//! Substitute for C++17 std::make_optional
-template <typename T>
-Optional<T> MakeOptional(bool condition, T&& value)
-{
-    return boost::make_optional(condition, std::forward<T>(value));
-}
-
-//! Substitute for C++17 std::nullopt
-static auto& nullopt = boost::none;
-
-#endif // DEFI_OPTIONAL_H
diff --git a/src/pos.cpp b/src/pos.cpp
index bc2d372b9f..06acea6083 100644
--- a/src/pos.cpp
+++ b/src/pos.cpp
@@ -183,7 +183,7 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, int64_t blockTim
     return pos::CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params.pos, newDifficultyAdjust);
 }
 
-boost::optional<std::string> SignPosBlock(std::shared_ptr<CBlock> pblock, const CKey &key) {
+std::optional<std::string> SignPosBlock(std::shared_ptr<CBlock> pblock, const CKey &key) {
     // if we are trying to sign a signed proof-of-stake block
     if (!pblock->sig.empty()) {
         throw std::logic_error{"Only non-complete PoS block templates are accepted"};
@@ -197,7 +197,7 @@ boost::optional<std::string> SignPosBlock(std::shared_ptr<CBlock> pblock, const
     return {};
 }
 
-boost::optional<std::string> CheckSignedBlock(const std::shared_ptr<CBlock>& pblock, const CBlockIndex* pindexPrev, const CChainParams& chainparams) {
+std::optional<std::string> CheckSignedBlock(const std::shared_ptr<CBlock>& pblock, const CBlockIndex* pindexPrev, const CChainParams& chainparams) {
     uint256 hashBlock = pblock->GetHash();
 
     // verify hash target and signature of coinstake tx
diff --git a/src/pos.h b/src/pos.h
index 039c0e2af9..0a4521bbdc 100644
--- a/src/pos.h
+++ b/src/pos.h
@@ -6,8 +6,6 @@
 #include <memory>
 #include <key.h>
 
-#include <boost/optional.hpp>
-
 class CBlock;
 
 class CBlockIndex;
@@ -46,9 +44,9 @@ namespace pos {
 
     unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params::PoS& params, bool newDifficultyAdjust = false);
 
-    boost::optional<std::string> SignPosBlock(std::shared_ptr<CBlock> pblock, const CKey &key);
+    std::optional<std::string> SignPosBlock(std::shared_ptr<CBlock> pblock, const CKey &key);
 
-    boost::optional<std::string> CheckSignedBlock(const std::shared_ptr<CBlock>& pblock, const CBlockIndex* pindexPrev, const CChainParams& chainparams);
+    std::optional<std::string> CheckSignedBlock(const std::shared_ptr<CBlock>& pblock, const CBlockIndex* pindexPrev, const CChainParams& chainparams);
 }
 
 #endif // DEFI_POS_H
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 733a5fa580..f3b50a0641 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -11,8 +11,6 @@
 #include <uint256.h>
 #include <pubkey.h>
 
-#include <boost/optional.hpp>
-
 /** Nodes collect new transactions into a block, hash them into a hash tree,
  * and scan through nonce values to make the block's hash satisfy proof-of-work
  * requirements.  When they solve the proof-of-work, they broadcast the block
diff --git a/src/psbt.cpp b/src/psbt.cpp
index dde14dc1f7..46dcfda9d2 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -214,7 +214,12 @@ bool PSBTInputSigned(const PSBTInput& input)
 
 void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index)
 {
-    const CTxOut& out = psbt.tx->vout.at(index);
+    if (!psbt.tx) {
+        return;
+    }
+
+    CMutableTransaction& tx = *psbt.tx;
+    const CTxOut& out = tx.vout.at(index);
     PSBTOutput& psbt_out = psbt.outputs.at(index);
 
     // Fill a SignatureData with output info
@@ -224,7 +229,7 @@ void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransactio
     // Construct a would-be spend of this output, to update sigdata with.
     // Note that ProduceSignature is used to fill in metadata (not actual signatures),
     // so provider does not need to provide any private keys (it can be a HidingSigningProvider).
-    MutableTransactionSignatureCreator creator(psbt.tx.get_ptr(), /* index */ 0, out.nValue, SIGHASH_ALL);
+    MutableTransactionSignatureCreator creator(&tx, /* index */ 0, out.nValue, SIGHASH_ALL);
     ProduceSignature(provider, creator, out.scriptPubKey, sigdata);
 
     // Put redeem_script, witness_script, key paths, into PSBTOutput.
diff --git a/src/psbt.h b/src/psbt.h
index 473719e513..f9fcf9d9c4 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -7,13 +7,14 @@
 
 #include <attributes.h>
 #include <node/transaction.h>
-#include <optional.h>
 #include <policy/feerate.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 
+#include <optional>
+
 // Magic bytes
 static constexpr uint8_t PSBT_MAGIC_BYTES[5] = {'p', 's', 'b', 't', 0xff};
 
@@ -388,7 +389,7 @@ struct PSBTOutput
 /** A version of CTransaction with the PSBT format*/
 struct PartiallySignedTransaction
 {
-    boost::optional<CMutableTransaction> tx;
+    std::optional<CMutableTransaction> tx;
     std::vector<PSBTInput> inputs;
     std::vector<PSBTOutput> outputs;
     std::map<std::vector<unsigned char>, std::vector<unsigned char>> unknown;
diff --git a/src/random.cpp b/src/random.cpp
index 5f789d1101..e0f86c7829 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -542,7 +542,7 @@ static void SeedSleep(CSHA512& hasher, RNGState& rng)
     SeedTimestamp(hasher);
 
     // Sleep for 1ms
-    MilliSleep(1);
+    UninterruptibleSleep(std::chrono::milliseconds{1});
 
     // High-precision timestamp after sleeping (as we commit to both the time before and after, this measures the delay)
     SeedTimestamp(hasher);
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index c041cafa48..b9dbeaffc5 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -25,7 +25,6 @@
 #include <script/descriptor.h>
 #include <streams.h>
 #include <sync.h>
-#include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
 #include <util/strencodings.h>
@@ -33,7 +32,6 @@
 #include <util/validation.h>
 #include <validation.h>
 #include <validationinterface.h>
-#include <versionbitsinfo.h>
 #include <warnings.h>
 
 #include <assert.h>
@@ -41,8 +39,6 @@
 
 #include <univalue.h>
 
-#include <boost/thread/thread.hpp> // boost::thread::interrupt
-
 #include <condition_variable>
 #include <memory>
 #include <mutex>
@@ -1078,7 +1074,7 @@ static UniValue gettxoutsetinfo(const JSONRPCRequest& request)
     ::ChainstateActive().ForceFlushStateToDisk();
 
     CCoinsView* coins_view = WITH_LOCK(cs_main, return &ChainstateActive().CoinsDB());
-    if (GetUTXOStats(coins_view, stats)) {
+    if (GetUTXOStats(coins_view, stats, RpcInterruptionPoint)) {
         ret.pushKV("height", (int64_t)stats.nHeight);
         ret.pushKV("bestblock", stats.hashBlock.GetHex());
         ret.pushKV("transactions", (int64_t)stats.nTransactions);
@@ -2062,7 +2058,7 @@ bool FindScriptPubKey(std::atomic<int>& scan_progress, const std::atomic<bool>&
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) return false;
         if (++count % 8192 == 0) {
-            boost::this_thread::interruption_point();
+            RpcInterruptionPoint();
             if (should_abort) {
                 // allow to abort the scan via the abort reference
                 return false;
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 014830ce4e..8713ad1a9d 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -33,8 +33,6 @@
 #include <wallet/wallet.h>
 #include <warnings.h>
 
-#include <boost/thread.hpp>
-
 #include <memory>
 #include <stdint.h>
 
@@ -120,7 +118,7 @@ static UniValue generateBlocks(const CScript& coinbase_script, const CKey & mint
     int64_t nTried = 0;
 
     while (true) {
-        boost::this_thread::interruption_point();
+        if (ShutdownRequested()) break;
 
         try {
             auto status = staker.init(Params());
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 72abe7adf8..951ff5177b 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -276,7 +276,7 @@ static UniValue verifymessage(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const PKHash *pkhash = boost::get<PKHash>(&destination);
+    const PKHash *pkhash = std::get_if<PKHash>(&destination);
     if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index ead0b9c594..4316fbfd35 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1705,13 +1705,13 @@ UniValue analyzepsbt(const JSONRPCRequest& request)
     }
     result.pushKV("inputs", inputs_result);
 
-    if (psbta.estimated_vsize != nullopt) {
+    if (psbta.estimated_vsize) {
         result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);
     }
-    if (psbta.estimated_feerate != nullopt) {
+    if (psbta.estimated_feerate) {
         result.pushKV("estimated_feerate", ValueFromAmount(psbta.estimated_feerate->GetFeePerK()));
     }
-    if (psbta.fee != nullopt) {
+    if (psbta.fee) {
         result.pushKV("fee", ValueFromAmount(*psbta.fee));
     }
     result.pushKV("next", PSBTRoleName(psbta.next));
diff --git a/src/rpc/rawtransaction_util.cpp b/src/rpc/rawtransaction_util.cpp
index 30467cb458..4448528422 100644
--- a/src/rpc/rawtransaction_util.cpp
+++ b/src/rpc/rawtransaction_util.cpp
@@ -148,7 +148,7 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
     UniValue outputs = outputs_is_obj ? outputs_in.get_obj() : outputs_in.get_array();
 
     auto locked_chain = chain.lock();
-    const auto txVersion = GetTransactionVersion(locked_chain->getHeight().get_value_or(-1));
+    const auto txVersion = GetTransactionVersion(locked_chain->getHeight().value_or(-1));
     CMutableTransaction rawTx(txVersion);
 
     if (!locktime.isNull()) {
diff --git a/src/rpc/rawtransaction_util.h b/src/rpc/rawtransaction_util.h
index f1580a1263..7d4ca649e7 100644
--- a/src/rpc/rawtransaction_util.h
+++ b/src/rpc/rawtransaction_util.h
@@ -32,8 +32,6 @@ CTokenAmount DecodeAmount(interfaces::Chain const & chain, UniValue const& amoun
 CBalances DecodeAmounts(interfaces::Chain const & chain, UniValue const& amountsUni, std::string const& name);
 CAccounts DecodeRecipients(interfaces::Chain const & chain, UniValue const& sendTo);
 
-std::function<void(std::string)> JSONRPCErrorThrower(int code, const std::string& prefix);
-
 /**
  * Sign a transaction with the given keystore and previous transactions
  *
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 6d237de480..3a412bf9a5 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -171,7 +171,7 @@ UniValue stop(const JSONRPCRequest& jsonRequest)
     // this reply will get back to the client.
     StartShutdown();
     if (jsonRequest.params[0].isNum()) {
-        MilliSleep(jsonRequest.params[0].get_int());
+        UninterruptibleSleep(std::chrono::milliseconds{jsonRequest.params[0].get_int()});
     }
     return "Defi server stopping";
 }
@@ -307,6 +307,11 @@ bool IsRPCRunning()
     return g_rpc_running;
 }
 
+void RpcInterruptionPoint()
+{
+    if (!IsRPCRunning()) throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
+}
+
 void SetRPCWarmupStatus(const std::string& newStatus)
 {
     LOCK(cs_rpcWarmup);
diff --git a/src/rpc/server.h b/src/rpc/server.h
index 6395376a0d..3c90b1f1b3 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -31,6 +31,9 @@ namespace RPCServer
 /** Query whether RPC is running */
 bool IsRPCRunning();
 
+/** Throw JSONRPCError if RPC is not running */
+void RpcInterruptionPoint();
+
 /**
  * Set the RPC warmup status.  When this is done, all RPC calls will error out
  * immediately with RPC_IN_WARMUP.
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 4933335e18..3b72858615 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -187,7 +187,7 @@ CTxDestination AddAndGetMultisigDestination(const int required, const std::vecto
     return dest;
 }
 
-class DescribeAddressVisitor : public boost::static_visitor<UniValue>
+class DescribeAddressVisitor
 {
 public:
     explicit DescribeAddressVisitor() {}
@@ -245,7 +245,7 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
 
 UniValue DescribeAddress(const CTxDestination& dest)
 {
-    return boost::apply_visitor(DescribeAddressVisitor(), dest);
+    return std::visit(DescribeAddressVisitor(), dest);
 }
 
 unsigned int ParseConfirmTarget(const UniValue& value, unsigned int max_target)
@@ -516,10 +516,10 @@ std::string RPCHelpMan::ToString() const
 
 bool RPCArg::IsOptional() const
 {
-    if (m_fallback.which() == PKHashType) {
+    if (m_fallback.index() == PKHashType) {
         return true;
     } else {
-        return RPCArg::Optional::NO != boost::get<RPCArg::Optional>(m_fallback);
+        return RPCArg::Optional::NO != std::get<RPCArg::Optional>(m_fallback);
     }
 }
 
@@ -565,10 +565,10 @@ std::string RPCArg::ToDescriptionString() const
             // no default case, so the compiler can warn about missing cases
         }
     }
-    if (m_fallback.which() == PKHashType) {
-        ret += ", optional, default=" + boost::get<std::string>(m_fallback);
+    if (m_fallback.index() == PKHashType) {
+        ret += ", optional, default=" + std::get<std::string>(m_fallback);
     } else {
-        switch (boost::get<RPCArg::Optional>(m_fallback)) {
+        switch (std::get<RPCArg::Optional>(m_fallback)) {
         case RPCArg::Optional::OMITTED: {
             // nothing to do. Element is treated as if not present and has no default value
             break;
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 4ecfc5e93e..7d1816484d 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -18,7 +18,7 @@
 #include <string>
 #include <vector>
 
-#include <boost/variant.hpp>
+#include <variant>
 
 class FillableSigningProvider;
 class CPubKey;
@@ -119,7 +119,7 @@ struct RPCArg {
          */
         OMITTED,
     };
-    using Fallback = boost::variant<Optional, /* default value for optional args */ std::string>;
+    using Fallback = std::variant<Optional, /* default value for optional args */ std::string>;
     const std::string m_name; //!< The name of the arg (can be empty for inner args)
     const Type m_type;
     const std::vector<RPCArg> m_inner; //!< Only used for arrays or dicts
diff --git a/src/scheduler.cpp b/src/scheduler.cpp
index e949234629..c6b118d726 100644
--- a/src/scheduler.cpp
+++ b/src/scheduler.cpp
@@ -20,18 +20,9 @@ CScheduler::~CScheduler()
 }
 
 
-#if BOOST_VERSION < 105000
-static boost::system_time toPosixTime(const boost::chrono::system_clock::time_point& t)
-{
-    // Creating the posix_time using from_time_t loses sub-second precision. So rather than exporting the time_point to time_t,
-    // start with a posix_time at the epoch (0) and add the milliseconds that have passed since then.
-    return boost::posix_time::from_time_t(0) + boost::posix_time::milliseconds(boost::chrono::duration_cast<boost::chrono::milliseconds>(t.time_since_epoch()).count());
-}
-#endif
-
 void CScheduler::serviceQueue()
 {
-    boost::unique_lock<boost::mutex> lock(newTaskMutex);
+    WAIT_LOCK(newTaskMutex, lock);
     ++nThreadsServicingQueue;
 
     // newTaskMutex is locked throughout this loop EXCEPT
@@ -40,7 +31,6 @@ void CScheduler::serviceQueue()
     while (!shouldStop()) {
         try {
             if (!shouldStop() && taskQueue.empty()) {
-                reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
                 // Use this chance to get more entropy
                 RandAddSeedSleep();
             }
@@ -52,21 +42,13 @@ void CScheduler::serviceQueue()
             // Wait until either there is a new task, or until
             // the time of the first item on the queue:
 
-// wait_until needs boost 1.50 or later; older versions have timed_wait:
-#if BOOST_VERSION < 105000
-            while (!shouldStop() && !taskQueue.empty() &&
-                   newTaskScheduled.timed_wait(lock, toPosixTime(taskQueue.begin()->first))) {
-                // Keep waiting until timeout
-            }
-#else
-            // Some boost versions have a conflicting overload of wait_until that returns void.
-            // Explicitly use a template here to avoid hitting that overload.
             while (!shouldStop() && !taskQueue.empty()) {
-                boost::chrono::system_clock::time_point timeToWaitFor = taskQueue.begin()->first;
-                if (newTaskScheduled.wait_until<>(lock, timeToWaitFor) == boost::cv_status::timeout)
+                std::chrono::system_clock::time_point timeToWaitFor = taskQueue.begin()->first;
+                if (newTaskScheduled.wait_until(lock, timeToWaitFor) == std::cv_status::timeout) {
                     break; // Exit loop after timeout, it means we reached the time of the event
+                }
             }
-#endif
+
             // If there are multiple threads, the queue can empty while we're waiting (another
             // thread may service the task we were waiting on).
             if (shouldStop() || taskQueue.empty())
@@ -78,7 +60,7 @@ void CScheduler::serviceQueue()
             {
                 // Unlock before calling f, so it can reschedule itself or another task
                 // without deadlocking:
-                reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+                reverse_lock<std::unique_lock<std::mutex> > rlock(lock);
                 f();
             }
         } catch (...) {
@@ -90,22 +72,10 @@ void CScheduler::serviceQueue()
     newTaskScheduled.notify_one();
 }
 
-void CScheduler::stop(bool drain)
-{
-    {
-        boost::unique_lock<boost::mutex> lock(newTaskMutex);
-        if (drain)
-            stopWhenEmpty = true;
-        else
-            stopRequested = true;
-    }
-    newTaskScheduled.notify_all();
-}
-
-void CScheduler::schedule(CScheduler::Function f, boost::chrono::system_clock::time_point t)
+void CScheduler::schedule(CScheduler::Function f, std::chrono::system_clock::time_point t)
 {
     {
-        boost::unique_lock<boost::mutex> lock(newTaskMutex);
+        LOCK(newTaskMutex);
         taskQueue.insert(std::make_pair(t, f));
     }
     newTaskScheduled.notify_one();
@@ -113,7 +83,7 @@ void CScheduler::schedule(CScheduler::Function f, boost::chrono::system_clock::t
 
 void CScheduler::scheduleFromNow(CScheduler::Function f, int64_t deltaMilliSeconds)
 {
-    schedule(f, boost::chrono::system_clock::now() + boost::chrono::milliseconds(deltaMilliSeconds));
+    schedule(f, std::chrono::system_clock::now() + std::chrono::milliseconds(deltaMilliSeconds));
 }
 
 static void Repeat(CScheduler* s, CScheduler::Function f, int64_t deltaMilliSeconds)
@@ -127,10 +97,10 @@ void CScheduler::scheduleEvery(CScheduler::Function f, int64_t deltaMilliSeconds
     scheduleFromNow(std::bind(&Repeat, this, f, deltaMilliSeconds), deltaMilliSeconds);
 }
 
-size_t CScheduler::getQueueInfo(boost::chrono::system_clock::time_point &first,
-                             boost::chrono::system_clock::time_point &last) const
+size_t CScheduler::getQueueInfo(std::chrono::system_clock::time_point &first,
+                                std::chrono::system_clock::time_point &last) const
 {
-    boost::unique_lock<boost::mutex> lock(newTaskMutex);
+    LOCK(newTaskMutex);
     size_t result = taskQueue.size();
     if (!taskQueue.empty()) {
         first = taskQueue.begin()->first;
@@ -140,7 +110,7 @@ size_t CScheduler::getQueueInfo(boost::chrono::system_clock::time_point &first,
 }
 
 bool CScheduler::AreThreadsServicingQueue() const {
-    boost::unique_lock<boost::mutex> lock(newTaskMutex);
+    LOCK(newTaskMutex);
     return nThreadsServicingQueue;
 }
 
@@ -154,7 +124,7 @@ void SingleThreadedSchedulerClient::MaybeScheduleProcessQueue() {
         if (m_are_callbacks_running) return;
         if (m_callbacks_pending.empty()) return;
     }
-    m_pscheduler->schedule(std::bind(&SingleThreadedSchedulerClient::ProcessQueue, this));
+    m_pscheduler->schedule(std::bind(&SingleThreadedSchedulerClient::ProcessQueue, this), std::chrono::system_clock::now());
 }
 
 void SingleThreadedSchedulerClient::ProcessQueue() {
diff --git a/src/scheduler.h b/src/scheduler.h
index 65cf1a78d8..8f2873fece 100644
--- a/src/scheduler.h
+++ b/src/scheduler.h
@@ -5,14 +5,11 @@
 #ifndef DEFI_SCHEDULER_H
 #define DEFI_SCHEDULER_H
 
-//
-// NOTE:
-// boost::thread / boost::chrono should be ported to std::thread / std::chrono
-// when we support C++11.
-//
-#include <boost/chrono/chrono.hpp>
-#include <boost/thread.hpp>
+#include <condition_variable>
+#include <functional>
+#include <list>
 #include <map>
+#include <thread>
 
 #include <sync.h>
 
@@ -27,8 +24,8 @@
 // s->scheduleFromNow(std::bind(Class::func, this, argument), 3);
 // boost::thread* t = new boost::thread(std::bind(CScheduler::serviceQueue, s));
 //
-// ... then at program shutdown, clean up the thread running serviceQueue:
-// t->interrupt();
+// ... then at program shutdown, make sure to call stop() to clean up the thread(s) running serviceQueue:
+// s->stop();
 // t->join();
 // delete t;
 // delete s; // Must be done after thread is interrupted/joined.
@@ -40,10 +37,12 @@ class CScheduler
     CScheduler();
     ~CScheduler();
 
+    std::thread m_service_thread;
+
     typedef std::function<void()> Function;
 
     // Call func at/after time t
-    void schedule(Function f, boost::chrono::system_clock::time_point t=boost::chrono::system_clock::now());
+    void schedule(Function f, std::chrono::system_clock::time_point t);
 
     // Convenience method: call f once deltaMilliSeconds from now
     void scheduleFromNow(Function f, int64_t deltaMilliSeconds);
@@ -58,30 +57,39 @@ class CScheduler
     // To keep things as simple as possible, there is no unschedule.
 
     // Services the queue 'forever'. Should be run in a thread,
-    // and interrupted using boost::interrupt_thread
     void serviceQueue();
 
-    // Tell any threads running serviceQueue to stop as soon as they're
-    // done servicing whatever task they're currently servicing (drain=false)
-    // or when there is no work left to be done (drain=true)
-    void stop(bool drain=false);
+    /** Tell any threads running serviceQueue to stop as soon as the current task is done */
+    void stop()
+    {
+        WITH_LOCK(newTaskMutex, stopRequested = true);
+        newTaskScheduled.notify_all();
+        if (m_service_thread.joinable()) m_service_thread.join();
+    }
+    /** Tell any threads running serviceQueue to stop when there is no work left to be done */
+    void StopWhenDrained()
+    {
+        WITH_LOCK(newTaskMutex, stopWhenEmpty = true);
+        newTaskScheduled.notify_all();
+        if (m_service_thread.joinable()) m_service_thread.join();
+    }
 
     // Returns number of tasks waiting to be serviced,
     // and first and last task times
-    size_t getQueueInfo(boost::chrono::system_clock::time_point &first,
-                        boost::chrono::system_clock::time_point &last) const;
+    size_t getQueueInfo(std::chrono::system_clock::time_point &first,
+                        std::chrono::system_clock::time_point &last) const;
 
     // Returns true if there are threads actively running in serviceQueue()
     bool AreThreadsServicingQueue() const;
 
 private:
-    std::multimap<boost::chrono::system_clock::time_point, Function> taskQueue;
-    boost::condition_variable newTaskScheduled;
-    mutable boost::mutex newTaskMutex;
-    int nThreadsServicingQueue;
-    bool stopRequested;
-    bool stopWhenEmpty;
-    bool shouldStop() const { return stopRequested || (stopWhenEmpty && taskQueue.empty()); }
+    mutable Mutex newTaskMutex;
+    std::condition_variable newTaskScheduled;
+    std::multimap<std::chrono::system_clock::time_point, Function> taskQueue GUARDED_BY(newTaskMutex);
+    int nThreadsServicingQueue GUARDED_BY(newTaskMutex);
+    bool stopRequested GUARDED_BY(newTaskMutex);
+    bool stopWhenEmpty GUARDED_BY(newTaskMutex);
+    bool shouldStop() const EXCLUSIVE_LOCKS_REQUIRED(newTaskMutex) { return stopRequested || (stopWhenEmpty && taskQueue.empty()); }
 };
 
 /**
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index df38354f4d..9f74f79b78 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -727,7 +727,7 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char>& sp, boo
             CPubKey pubkey(data);
             if (pubkey.IsFullyValid()) {
                 if (permit_uncompressed || pubkey.IsCompressed()) {
-                    return MakeUnique<ConstPubkeyProvider>(pubkey);
+                    return std::make_unique<ConstPubkeyProvider>(pubkey);
                 } else {
                     error = "Uncompressed keys are not allowed";
                     return nullptr;
@@ -741,7 +741,7 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char>& sp, boo
             if (permit_uncompressed || key.IsCompressed()) {
                 CPubKey pubkey = key.GetPubKey();
                 out.keys.emplace(pubkey.GetID(), key);
-                return MakeUnique<ConstPubkeyProvider>(pubkey);
+                return std::make_unique<ConstPubkeyProvider>(pubkey);
             } else {
                 error = "Uncompressed keys are not allowed";
                 return nullptr;
@@ -768,7 +768,7 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char>& sp, boo
         extpubkey = extkey.Neuter();
         out.keys.emplace(extpubkey.pubkey.GetID(), extkey.key);
     }
-    return MakeUnique<BIP32PubkeyProvider>(extpubkey, std::move(path), type);
+    return std::make_unique<BIP32PubkeyProvider>(extpubkey, std::move(path), type);
 }
 
 /** Parse a public key including origin information (if enabled). */
@@ -802,7 +802,7 @@ std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char>& sp, bool per
     if (!ParseKeyPath(slash_split, info.path, error)) return nullptr;
     auto provider = ParsePubkeyInner(origin_split[1], permit_uncompressed, out, error);
     if (!provider) return nullptr;
-    return MakeUnique<OriginPubkeyProvider>(std::move(info), std::move(provider));
+    return std::make_unique<OriginPubkeyProvider>(std::move(info), std::move(provider));
 }
 
 /** Parse a script in a particular context. */
@@ -812,17 +812,17 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
     if (Func("pk", expr)) {
         auto pubkey = ParsePubkey(expr, ctx != ParseScriptContext::P2WSH, out, error);
         if (!pubkey) return nullptr;
-        return MakeUnique<PKDescriptor>(std::move(pubkey));
+        return std::make_unique<PKDescriptor>(std::move(pubkey));
     }
     if (Func("pkh", expr)) {
         auto pubkey = ParsePubkey(expr, ctx != ParseScriptContext::P2WSH, out, error);
         if (!pubkey) return nullptr;
-        return MakeUnique<PKHDescriptor>(std::move(pubkey));
+        return std::make_unique<PKHDescriptor>(std::move(pubkey));
     }
     if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
         auto pubkey = ParsePubkey(expr, true, out, error);
         if (!pubkey) return nullptr;
-        return MakeUnique<ComboDescriptor>(std::move(pubkey));
+        return std::make_unique<ComboDescriptor>(std::move(pubkey));
     } else if (ctx != ParseScriptContext::TOP && Func("combo", expr)) {
         error = "Cannot have combo in non-top level";
         return nullptr;
@@ -869,12 +869,12 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
                 return nullptr;
             }
         }
-        return MakeUnique<MultisigDescriptor>(thres, std::move(providers));
+        return std::make_unique<MultisigDescriptor>(thres, std::move(providers));
     }
     if (ctx != ParseScriptContext::P2WSH && Func("wpkh", expr)) {
         auto pubkey = ParsePubkey(expr, false, out, error);
         if (!pubkey) return nullptr;
-        return MakeUnique<WPKHDescriptor>(std::move(pubkey));
+        return std::make_unique<WPKHDescriptor>(std::move(pubkey));
     } else if (ctx == ParseScriptContext::P2WSH && Func("wpkh", expr)) {
         error = "Cannot have wpkh within wsh";
         return nullptr;
@@ -882,7 +882,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
     if (ctx == ParseScriptContext::TOP && Func("sh", expr)) {
         auto desc = ParseScript(expr, ParseScriptContext::P2SH, out, error);
         if (!desc || expr.size()) return nullptr;
-        return MakeUnique<SHDescriptor>(std::move(desc));
+        return std::make_unique<SHDescriptor>(std::move(desc));
     } else if (ctx != ParseScriptContext::TOP && Func("sh", expr)) {
         error = "Cannot have sh in non-top level";
         return nullptr;
@@ -890,7 +890,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
     if (ctx != ParseScriptContext::P2WSH && Func("wsh", expr)) {
         auto desc = ParseScript(expr, ParseScriptContext::P2WSH, out, error);
         if (!desc || expr.size()) return nullptr;
-        return MakeUnique<WSHDescriptor>(std::move(desc));
+        return std::make_unique<WSHDescriptor>(std::move(desc));
     } else if (ctx == ParseScriptContext::P2WSH && Func("wsh", expr)) {
         error = "Cannot have wsh within wsh";
         return nullptr;
@@ -901,7 +901,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
             error = "Address is not valid";
             return nullptr;
         }
-        return MakeUnique<AddressDescriptor>(std::move(dest));
+        return std::make_unique<AddressDescriptor>(std::move(dest));
     }
     if (ctx == ParseScriptContext::TOP && Func("raw", expr)) {
         std::string str(expr.begin(), expr.end());
@@ -910,7 +910,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
             return nullptr;
         }
         auto bytes = ParseHex(str);
-        return MakeUnique<RawDescriptor>(CScript(bytes.begin(), bytes.end()));
+        return std::make_unique<RawDescriptor>(CScript(bytes.begin(), bytes.end()));
     }
     if (ctx == ParseScriptContext::P2SH) {
         error = "A function is needed within P2SH";
@@ -925,10 +925,10 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
 
 std::unique_ptr<PubkeyProvider> InferPubkey(const CPubKey& pubkey, ParseScriptContext, const SigningProvider& provider)
 {
-    std::unique_ptr<PubkeyProvider> key_provider = MakeUnique<ConstPubkeyProvider>(pubkey);
+    std::unique_ptr<PubkeyProvider> key_provider = std::make_unique<ConstPubkeyProvider>(pubkey);
     KeyOriginInfo info;
     if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
-        return MakeUnique<OriginPubkeyProvider>(std::move(info), std::move(key_provider));
+        return std::make_unique<OriginPubkeyProvider>(std::move(info), std::move(key_provider));
     }
     return key_provider;
 }
@@ -941,7 +941,7 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
     if (txntype == TX_PUBKEY) {
         CPubKey pubkey(data[0].begin(), data[0].end());
         if (pubkey.IsValid()) {
-            return MakeUnique<PKDescriptor>(InferPubkey(pubkey, ctx, provider));
+            return std::make_unique<PKDescriptor>(InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_PUBKEYHASH) {
@@ -949,7 +949,7 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
         CKeyID keyid(hash);
         CPubKey pubkey;
         if (provider.GetPubKey(keyid, pubkey)) {
-            return MakeUnique<PKHDescriptor>(InferPubkey(pubkey, ctx, provider));
+            return std::make_unique<PKHDescriptor>(InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_WITNESS_V0_KEYHASH && ctx != ParseScriptContext::P2WSH) {
@@ -957,7 +957,7 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
         CKeyID keyid(hash);
         CPubKey pubkey;
         if (provider.GetPubKey(keyid, pubkey)) {
-            return MakeUnique<WPKHDescriptor>(InferPubkey(pubkey, ctx, provider));
+            return std::make_unique<WPKHDescriptor>(InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_MULTISIG) {
@@ -966,7 +966,7 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
             CPubKey pubkey(data[i].begin(), data[i].end());
             providers.push_back(InferPubkey(pubkey, ctx, provider));
         }
-        return MakeUnique<MultisigDescriptor>((int)data[0][0], std::move(providers));
+        return std::make_unique<MultisigDescriptor>((int)data[0][0], std::move(providers));
     }
     if (txntype == TX_SCRIPTHASH && ctx == ParseScriptContext::TOP) {
         uint160 hash(data[0]);
@@ -974,7 +974,7 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
         CScript subscript;
         if (provider.GetCScript(scriptid, subscript)) {
             auto sub = InferScript(subscript, ParseScriptContext::P2SH, provider);
-            if (sub) return MakeUnique<SHDescriptor>(std::move(sub));
+            if (sub) return std::make_unique<SHDescriptor>(std::move(sub));
         }
     }
     if (txntype == TX_WITNESS_V0_SCRIPTHASH && ctx != ParseScriptContext::P2WSH) {
@@ -983,18 +983,18 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
         CScript subscript;
         if (provider.GetCScript(scriptid, subscript)) {
             auto sub = InferScript(subscript, ParseScriptContext::P2WSH, provider);
-            if (sub) return MakeUnique<WSHDescriptor>(std::move(sub));
+            if (sub) return std::make_unique<WSHDescriptor>(std::move(sub));
         }
     }
 
     CTxDestination dest;
     if (ExtractDestination(script, dest)) {
         if (GetScriptForDestination(dest) == script) {
-            return MakeUnique<AddressDescriptor>(std::move(dest));
+            return std::make_unique<AddressDescriptor>(std::move(dest));
         }
     }
 
-    return MakeUnique<RawDescriptor>(script);
+    return std::make_unique<RawDescriptor>(script);
 }
 
 
diff --git a/src/script/sigcache.cpp b/src/script/sigcache.cpp
index 3d42f99618..169e25e9a8 100644
--- a/src/script/sigcache.cpp
+++ b/src/script/sigcache.cpp
@@ -11,7 +11,11 @@
 #include <util/system.h>
 
 #include <cuckoocache.h>
-#include <boost/thread.hpp>
+
+#include <algorithm>
+#include <mutex>
+#include <shared_mutex>
+#include <vector>
 
 namespace {
 /**
@@ -26,7 +30,7 @@ class CSignatureCache
     uint256 nonce;
     typedef CuckooCache::cache<uint256, SignatureCacheHasher> map_type;
     map_type setValid;
-    boost::shared_mutex cs_sigcache;
+    std::shared_mutex cs_sigcache;
 
 public:
     CSignatureCache()
@@ -43,13 +47,13 @@ class CSignatureCache
     bool
     Get(const uint256& entry, const bool erase)
     {
-        boost::shared_lock<boost::shared_mutex> lock(cs_sigcache);
+        std::shared_lock<std::shared_mutex> lock(cs_sigcache);
         return setValid.contains(entry, erase);
     }
 
     void Set(uint256& entry)
     {
-        boost::unique_lock<boost::shared_mutex> lock(cs_sigcache);
+        std::unique_lock<std::shared_mutex> lock(cs_sigcache);
         setValid.insert(entry);
     }
     uint32_t setup_bytes(size_t n)
diff --git a/src/script/sign.h b/src/script/sign.h
index d047c60794..49f021d034 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -6,7 +6,6 @@
 #ifndef DEFI_SCRIPT_SIGN_H
 #define DEFI_SCRIPT_SIGN_H
 
-#include <boost/optional.hpp>
 #include <hash.h>
 #include <pubkey.h>
 #include <script/interpreter.h>
diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
index 6aacd6803f..9fe72f7634 100644
--- a/src/script/signingprovider.cpp
+++ b/src/script/signingprovider.cpp
@@ -179,21 +179,21 @@ CKeyID GetKeyForDestination(const SigningProvider& store, const CTxDestination&
 {
     // Only supports destinations which map to single public keys, i.e. P2PKH,
     // P2WPKH, and P2SH-P2WPKH.
-    if (auto id = boost::get<PKHash>(&dest)) {
+    if (auto id = std::get_if<PKHash>(&dest)) {
         return CKeyID(*id);
     }
-    if (auto witness_id = boost::get<WitnessV0KeyHash>(&dest)) {
+    if (auto witness_id = std::get_if<WitnessV0KeyHash>(&dest)) {
         return CKeyID(*witness_id);
     }
-    if (auto script_hash = boost::get<ScriptHash>(&dest)) {
+    if (auto script_hash = std::get_if<ScriptHash>(&dest)) {
         CScript script;
         CScriptID script_id(*script_hash);
         CTxDestination inner_dest;
         if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) {
-            if (auto inner_witness_id = boost::get<WitnessV0KeyHash>(&inner_dest)) {
+            if (auto inner_witness_id = std::get_if<WitnessV0KeyHash>(&inner_dest)) {
                 return CKeyID(*inner_witness_id);
             }
         }
     }
-    return CKeyID();
+    return {};
 }
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 6c0dacd21a..2f00a7f2a5 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -237,51 +237,38 @@ bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, std::
     return true;
 }
 
-namespace
+namespace {
+class CScriptVisitor
 {
-class CScriptVisitor : public boost::static_visitor<bool>
-{
-private:
-    CScript *script;
 public:
-    explicit CScriptVisitor(CScript *scriptin) { script = scriptin; }
-
-    bool operator()(const CNoDestination &dest) const {
-        script->clear();
-        return false;
+    CScript operator()(const CNoDestination& dest) const
+    {
+        return CScript();
     }
 
-    bool operator()(const PKHash &keyID) const {
-        script->clear();
-        *script << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
-        return true;
+    CScript operator()(const PKHash& keyID) const
+    {
+        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
     }
 
-    bool operator()(const ScriptHash &scriptID) const {
-        script->clear();
-        *script << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
-        return true;
+    CScript operator()(const ScriptHash& scriptID) const
+    {
+        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
     }
 
-    bool operator()(const WitnessV0KeyHash& id) const
+    CScript operator()(const WitnessV0KeyHash& id) const
     {
-        script->clear();
-        *script << OP_0 << ToByteVector(id);
-        return true;
+        return CScript() << OP_0 << ToByteVector(id);
     }
 
-    bool operator()(const WitnessV0ScriptHash& id) const
+    CScript operator()(const WitnessV0ScriptHash& id) const
     {
-        script->clear();
-        *script << OP_0 << ToByteVector(id);
-        return true;
+        return CScript() << OP_0 << ToByteVector(id);
     }
 
-    bool operator()(const WitnessUnknown& id) const
+    CScript operator()(const WitnessUnknown& id) const
     {
-        script->clear();
-        *script << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
-        return true;
+        return CScript() << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
     }
 };
 } // namespace
@@ -290,8 +277,7 @@ CScript GetScriptForDestination(const CTxDestination& dest)
 {
     CScript script;
 
-    boost::apply_visitor(CScriptVisitor(&script), dest);
-    return script;
+    return std::visit(CScriptVisitor(), dest);
 }
 
 CScript GetScriptForRawPubKey(const CPubKey& pubKey)
@@ -347,5 +333,5 @@ CScript GetScriptForHTLC(const CPubKey& seller, const CPubKey& refund, const std
 }
 
 bool IsValidDestination(const CTxDestination& dest) {
-    return dest.which() != 0;
+    return dest.index() != 0;
 }
diff --git a/src/script/standard.h b/src/script/standard.h
index 71e76a11f9..8aa7678018 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -9,9 +9,8 @@
 #include <script/interpreter.h>
 #include <uint256.h>
 
-#include <boost/variant.hpp>
-
 #include <stdint.h>
+#include <variant>
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
@@ -136,7 +135,7 @@ struct WitnessUnknown
  *  * WitnessUnknown: TX_WITNESS_UNKNOWN destination (P2W???)
  *  A CTxDestination is the internal data type encoded in a DFI address
  */
-typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown> CTxDestination;
+using CTxDestination = std::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown>;
 
 enum TxDestType {
     NoDestType,
diff --git a/src/serialize_optional.h b/src/serialize_optional.h
index 7f7493109e..16be862260 100644
--- a/src/serialize_optional.h
+++ b/src/serialize_optional.h
@@ -2,10 +2,11 @@
 #define DEFI_SERIALIZE_OPTIONAL_H
 
 #include <serialize.h>
-#include <boost/optional.hpp>
+
+#include <optional>
 
 template<typename Stream, typename T>
-inline void Serialize(Stream& s, boost::optional<T> const & a)
+inline void Serialize(Stream& s, std::optional<T> const & a)
 {
     ::ser_writedata8(s, a ? 1 : 0);
     if (a) {
@@ -14,7 +15,7 @@ inline void Serialize(Stream& s, boost::optional<T> const & a)
 }
 
 template<typename Stream, typename T>
-inline void Unserialize(Stream& s, boost::optional<T>& a)
+inline void Unserialize(Stream& s, std::optional<T>& a)
 {
     const auto exist = ::ser_readdata8(s);
     if (exist == 1) {
diff --git a/src/span.h b/src/span.h
index 594dd0c241..d1ba93fb11 100644
--- a/src/span.h
+++ b/src/span.h
@@ -24,6 +24,23 @@ class Span
     constexpr Span(C* data, std::ptrdiff_t size) noexcept : m_data(data), m_size(size) {}
     constexpr Span(C* data, C* end) noexcept : m_data(data), m_size(end - data) {}
 
+    /** Implicit conversion of spans between compatible types.
+     *
+     *  Specifically, if a pointer to an array of type O can be implicitly converted to a pointer to an array of type
+     *  C, then permit implicit conversion of Span<O> to Span<C>. This matches the behavior of the corresponding
+     *  C++20 std::span constructor.
+     *
+     *  For example this means that a Span<T> can be converted into a Span<const T>.
+     */
+    template <typename O, typename std::enable_if<std::is_convertible<O (*)[], C (*)[]>::value, int>::type = 0>
+    constexpr Span(const Span<O>& other) noexcept : m_data(other.m_data), m_size(other.m_size) {}
+
+    /** Default copy constructor. */
+    constexpr Span(const Span&) noexcept = default;
+
+    /** Default assignment operator. */
+    Span& operator=(const Span& other) noexcept = default;
+
     constexpr C* data() const noexcept { return m_data; }
     constexpr C* begin() const noexcept { return m_data; }
     constexpr C* end() const noexcept { return m_data + m_size; }
@@ -41,6 +58,8 @@ class Span
     friend constexpr bool operator<=(const Span& a, const Span& b) noexcept { return !(b < a); }
     friend constexpr bool operator>(const Span& a, const Span& b) noexcept { return (b < a); }
     friend constexpr bool operator>=(const Span& a, const Span& b) noexcept { return !(a < b); }
+
+    template <typename O> friend class Span;
 };
 
 /** Create a span to a container exposing data() and size().
diff --git a/src/spv/bitcoin/BRPeer.cpp b/src/spv/bitcoin/BRPeer.cpp
index 0b9ec0affc..d372548817 100644
--- a/src/spv/bitcoin/BRPeer.cpp
+++ b/src/spv/bitcoin/BRPeer.cpp
@@ -35,6 +35,7 @@
 #include <float.h>
 #include <inttypes.h>
 #include <string.h>
+#include <thread>
 
 #include <compat.h>
 
@@ -44,7 +45,7 @@
 //#include <errno.h>
 //#include <netdb.h>
 //#include <sys/socket.h>
-//#include <sys/time.h>
+#include <sys/time.h>
 //#include <netinet/in.h>
 //#include <arpa/inet.h>
 
@@ -92,7 +93,7 @@
 
 char const * spv_logfilename = NULL;
 int spv_log2console = 1;
-boost::mutex log_mutex;
+std::mutex log_mutex;
 
 typedef enum {
     inv_undefined = 0,
@@ -140,8 +141,8 @@ typedef struct {
     void (**volatile pongCallback)(void *info, int success);
     void *volatile mempoolInfo;
     void (*volatile mempoolCallback)(void *info, int success);
-    std::unique_ptr<boost::thread> thread;
-    boost::mutex lock;
+    std::unique_ptr<std::thread> thread;
+    std::mutex lock;
 } BRPeerContext;
 
 void BRPeerSendVersionMessage(BRPeer *peer);
@@ -1297,9 +1298,7 @@ int BRPeerConnect(BRPeer *peer)
             // No race - set before the thread starts.
             ctx->disconnectTime = tv.tv_sec + (double)tv.tv_usec/1000000 + CONNECT_TIMEOUT;
             {
-                boost::thread::attributes attrs;
-                attrs.set_stack_size(PTHREAD_STACK_SIZE);
-                ctx->thread.reset(new boost::thread(attrs, boost::bind(_peerThreadRoutine, peer)));
+                ctx->thread.reset(new std::thread(std::bind(_peerThreadRoutine, peer)));
                 ctx->thread->detach();
                 ctx->lock.unlock();
                 return 1; // thread successful run
diff --git a/src/spv/bitcoin/BRPeer.h b/src/spv/bitcoin/BRPeer.h
index c2c821fcc9..3ce12206a0 100644
--- a/src/spv/bitcoin/BRPeer.h
+++ b/src/spv/bitcoin/BRPeer.h
@@ -29,9 +29,10 @@
 #include "BRMerkleBlock.h"
 #include "BRAddress.h"
 #include "BRInt.h"
+
 #include <stddef.h>
 #include <inttypes.h>
-#include <boost/thread.hpp>
+#include <mutex>
 
 /// define logs
 #define console_peer_log(peer, ...) { \
@@ -84,7 +85,7 @@
 
 extern char const * spv_logfilename;
 extern int spv_log2console;
-extern boost::mutex log_mutex;
+extern std::mutex log_mutex;
 
 #ifndef INET6_ADDRSTRLEN // defined in netinet/in.h
 #define INET6_ADDRSTRLEN 46
diff --git a/src/spv/bitcoin/BRPeerManager.cpp b/src/spv/bitcoin/BRPeerManager.cpp
index 58b4525698..5fd048225a 100644
--- a/src/spv/bitcoin/BRPeerManager.cpp
+++ b/src/spv/bitcoin/BRPeerManager.cpp
@@ -35,11 +35,10 @@
 #include <limits.h>
 #include <time.h>
 #include <assert.h>
+#include <thread>
 
 #include <compat.h>
 
-#include <boost/thread.hpp>
-
 //#include <pthread.h>
 //#include <errno.h>
 //#include <netdb.h>
@@ -206,7 +205,7 @@ struct BRPeerManagerStruct {
     void (*savePeers)(void *info, int replace, const BRPeer peers[], size_t peersCount);
     int (*networkIsReachable)(void *info);
     void (*threadCleanup)(void *info);
-    boost::mutex lock;
+    std::mutex lock;
 };
 
 static void _BRPeerManagerPeerMisbehavin(BRPeerManager *manager, BRPeer *peer)
@@ -779,7 +778,7 @@ static void _BRPeerManagerFindPeers(BRPeerManager *manager)
     else {
         size_t peerCount = array_count(manager->peers);
 
-        std::vector<boost::thread> tmpDnsThreads;
+        std::vector<std::thread> tmpDnsThreads;
 
         for (size_t i = 1; manager->params->dnsSeeds[i]; i++) {
             info = (BRFindPeersInfo *)calloc(1, sizeof(BRFindPeersInfo));
@@ -788,7 +787,7 @@ static void _BRPeerManagerFindPeers(BRPeerManager *manager)
             info->hostname = manager->params->dnsSeeds[i];
             info->services = services;
 
-            tmpDnsThreads.push_back(boost::thread(boost::bind(_findPeersThreadRoutine, info)));
+            tmpDnsThreads.push_back(std::thread(std::bind(_findPeersThreadRoutine, info)));
             tmpDnsThreads.back().detach();
             manager->dnsThreadCount++;
         }
diff --git a/src/spv/bitcoin/BRWallet.cpp b/src/spv/bitcoin/BRWallet.cpp
index edda8d51fe..28d30e0a4d 100644
--- a/src/spv/bitcoin/BRWallet.cpp
+++ b/src/spv/bitcoin/BRWallet.cpp
@@ -33,14 +33,7 @@
 #include <algorithm>
 #include <stdlib.h>
 #include <inttypes.h>
-#include <limits.h>
-#include <float.h>
 
-//#include <compat.h>
-
-#include <boost/thread.hpp>
-
-//#include <pthread.h>
 #include <assert.h>
 
 uint256 to_uint256(const UInt256 & i)
@@ -97,7 +90,7 @@ struct BRWalletStruct {
     void (*txAdded)(void *info, BRTransaction *tx);
     void (*txUpdated)(void *info, const UInt256 txHashes[], size_t txCount, uint32_t blockHeight, uint32_t timestamp, const UInt256& blockHash);
     void (*txDeleted)(void *info, UInt256 txHash, int notifyUser, int recommendRescan);
-    boost::mutex lock;
+    std::mutex lock;
 };
 
 inline static void _BRWalletAddressFromHash160(BRWallet *wallet, char *addr, size_t addrLen, UInt160 h)
diff --git a/src/spv/spv_rpc.cpp b/src/spv/spv_rpc.cpp
index e342285de4..a3ee578155 100644
--- a/src/spv/spv_rpc.cpp
+++ b/src/spv/spv_rpc.cpp
@@ -130,7 +130,7 @@ UniValue spv_createanchor(const JSONRPCRequest& request)
 
     std::string rewardAddress = request.params[1].getValStr();
     CTxDestination rewardDest = DecodeDestination(rewardAddress);
-    if (rewardDest.which() != 1 && rewardDest.which() != 4)
+    if (rewardDest.index() != 1 && rewardDest.index() != 4)
     {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "rewardAddress (" + rewardAddress + ") does not refer to a P2PKH or P2WPKH address");
     }
@@ -226,7 +226,7 @@ UniValue spv_createanchortemplate(const JSONRPCRequest& request)
 
     std::string rewardAddress = request.params[0].getValStr();
     CTxDestination rewardDest = DecodeDestination(rewardAddress);
-    if (rewardDest.which() != 1 && rewardDest.which() != 4) {
+    if (rewardDest.index() != 1 && rewardDest.index() != 4) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "rewardAddress (" + rewardAddress + ") does not refer to a P2PKH or P2WPKH address");
     }
 
diff --git a/src/spv/spv_wrapper.cpp b/src/spv/spv_wrapper.cpp
index ae37735169..8ebd525de7 100644
--- a/src/spv/spv_wrapper.cpp
+++ b/src/spv/spv_wrapper.cpp
@@ -251,10 +251,10 @@ void CSpvWrapper::Load()
             if (entry.second.purpose == "spv")
             {
                 uint160 userHash;
-                if (entry.first.which() == PKHashType) {
-                    userHash = *boost::get<PKHash>(&entry.first);
-                } else if (entry.first.which() == WitV0KeyHashType) {
-                    userHash = *boost::get<WitnessV0KeyHash>(&entry.first);
+                if (entry.first.index() == PKHashType) {
+                    userHash = std::get<PKHash>(entry.first);
+                } else if (entry.first.index() == WitV0KeyHashType) {
+                    userHash = std::get<WitnessV0KeyHash>(entry.first);
                 } else {
                     continue;
                 }
@@ -265,7 +265,7 @@ void CSpvWrapper::Load()
             }
             else if (entry.second.purpose == "htlc")
             {
-                uint160 userHash = *boost::get<ScriptHash>(&entry.first);
+                uint160 userHash = std::get<ScriptHash>(entry.first);
                 UInt160 spvHash;
                 UIntConvert(userHash.begin(), spvHash);
                 htlcAddresses->insert(spvHash);
@@ -1357,7 +1357,7 @@ UniValue CSpvWrapper::RefundAllHTLC(CWallet* const pwallet, const char *destinat
     for (const auto& item : wallets) {
         for (const auto& entry : item->mapAddressBook) {
             if (entry.second.purpose == "htlc") {
-                htlcAddresses.insert(*boost::get<ScriptHash>(&entry.first));
+                htlcAddresses.insert(std::get<ScriptHash>(entry.first));
             }
         }
     }
diff --git a/src/spv/spv_wrapper.h b/src/spv/spv_wrapper.h
index 8bb0365092..133217b0e9 100644
--- a/src/spv/spv_wrapper.h
+++ b/src/spv/spv_wrapper.h
@@ -18,9 +18,6 @@
 #include <utility>
 #include <vector>
 
-#include <boost/scoped_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/mem_fun.hpp>
 #include <boost/multi_index/member.hpp>
@@ -29,8 +26,6 @@
 #include <boost/multi_index/composite_key.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 
-#include <boost/thread.hpp>
-
 // Anchor DB storage version, increment to wipe anchor and SPV data.
 #define SPV_DB_VERSION 1
 
@@ -82,8 +77,8 @@ using namespace boost::multi_index;
 class CSpvWrapper
 {
 private:
-    boost::shared_ptr<CDBWrapper> db;
-    boost::scoped_ptr<CDBBatch> batch;
+    std::shared_ptr<CDBWrapper> db;
+    std::unique_ptr<CDBBatch> batch;
 
     BRPeerManager *manager = nullptr;
     std::string spv_internal_logfilename;
@@ -202,12 +197,12 @@ class CSpvWrapper
     template <typename Key, typename Value>
     bool IterateTable(char prefix, std::function<void(Key const &, Value &)> callback)
     {
-        boost::scoped_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
+        std::unique_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
         pcursor->Seek(prefix);
 
         while (pcursor->Valid())
         {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) break;
             std::pair<char, Key> key;
             if (pcursor->GetKey(key) && key.first == prefix)
             {
@@ -230,12 +225,12 @@ class CSpvWrapper
     template <typename Key>
     bool DeleteTable(char prefix)
     {
-        boost::scoped_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
+        std::unique_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&*db)->NewIterator());
         pcursor->Seek(prefix);
 
         while (pcursor->Valid())
         {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) break;
             std::pair<char, Key> key;
             if (pcursor->GetKey(key) && key.first == prefix)
             {
diff --git a/src/test/allocator_tests.cpp b/src/test/allocator_tests.cpp
index dd83ac695d..7315a4e72b 100644
--- a/src/test/allocator_tests.cpp
+++ b/src/test/allocator_tests.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/memory.h>
 #include <util/system.h>
 
 #include <test/setup_common.h>
@@ -163,7 +162,7 @@ class TestLockedPageAllocator: public LockedPageAllocator
 BOOST_AUTO_TEST_CASE(lockedpool_tests_mock)
 {
     // Test over three virtual arenas, of which one will succeed being locked
-    std::unique_ptr<LockedPageAllocator> x = MakeUnique<TestLockedPageAllocator>(3, 1);
+    std::unique_ptr<LockedPageAllocator> x = std::make_unique<TestLockedPageAllocator>(3, 1);
     LockedPool pool(std::move(x));
     BOOST_CHECK(pool.stats().total == 0);
     BOOST_CHECK(pool.stats().locked == 0);
diff --git a/src/test/anchor_tests.cpp b/src/test/anchor_tests.cpp
index f3aa4ced84..d6f246b857 100644
--- a/src/test/anchor_tests.cpp
+++ b/src/test/anchor_tests.cpp
@@ -13,7 +13,7 @@ struct SpvTestingSetup : public TestingSetup {
     SpvTestingSetup()
         : TestingSetup(CBaseChainParams::MAIN)
     {
-        spv::pspv = MakeUnique<spv::CFakeSpvWrapper>();
+        spv::pspv = std::make_unique<spv::CFakeSpvWrapper>();
     }
     ~SpvTestingSetup()
     {
diff --git a/src/test/blockencodings_tests.cpp b/src/test/blockencodings_tests.cpp
index 24eaf1477f..83bb2c9970 100644
--- a/src/test/blockencodings_tests.cpp
+++ b/src/test/blockencodings_tests.cpp
@@ -47,7 +47,7 @@ static CBlock BuildBlockTestCase() {
 
     minterKey = pos->second.operatorKey;
     CBlockIndex *tip;
-    boost::optional<int64_t> stakerBlockTime;
+    std::optional<int64_t> stakerBlockTime;
     {
         LOCK(cs_main);
         tip = ::ChainActive().Tip();
diff --git a/src/test/checkqueue_tests.cpp b/src/test/checkqueue_tests.cpp
index 43260047d4..b6248fb68c 100644
--- a/src/test/checkqueue_tests.cpp
+++ b/src/test/checkqueue_tests.cpp
@@ -2,15 +2,12 @@
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/memory.h>
 #include <util/system.h>
 #include <util/time.h>
-#include <validation.h>
 
 #include <test/setup_common.h>
 #include <checkqueue.h>
 #include <boost/test/unit_test.hpp>
-#include <boost/thread.hpp>
 #include <atomic>
 #include <thread>
 #include <vector>
@@ -19,11 +16,10 @@
 
 #include <unordered_set>
 
-// BasicTestingSetup not sufficient because nScriptCheckThreads is not set
-// otherwise.
 BOOST_FIXTURE_TEST_SUITE(checkqueue_tests, TestingSetup)
 
 static const unsigned int QUEUE_BATCH_SIZE = 128;
+static const int SCRIPT_CHECK_THREADS = 3;
 
 struct FakeCheck {
     bool operator()()
@@ -147,11 +143,8 @@ typedef CCheckQueue<FrozenCleanupCheck> FrozenCleanup_Queue;
  */
 static void Correct_Queue_range(std::vector<size_t> range)
 {
-    auto small_queue = MakeUnique<Correct_Queue>(QUEUE_BATCH_SIZE);
-    boost::thread_group tg;
-    for (auto x = 0; x < nScriptCheckThreads; ++x) {
-       tg.create_thread([&]{small_queue->Thread();});
-    }
+    auto small_queue = std::make_unique<Correct_Queue>(QUEUE_BATCH_SIZE);
+    small_queue->StartWorkerThreads(SCRIPT_CHECK_THREADS);
     // Make vChecks here to save on malloc (this test can be slow...)
     std::vector<FakeCheckCheckCompletion> vChecks;
     for (const size_t i : range) {
@@ -168,8 +161,7 @@ static void Correct_Queue_range(std::vector<size_t> range)
             BOOST_REQUIRE_EQUAL(FakeCheckCheckCompletion::n_calls, i);
         }
     }
-    tg.interrupt_all();
-    tg.join_all();
+    small_queue->StopWorkerThreads();
 }
 
 /** Test that 0 checks is correct
@@ -211,12 +203,8 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Random)
 /** Test that failing checks are caught */
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
 {
-    auto fail_queue = MakeUnique<Failing_Queue>(QUEUE_BATCH_SIZE);
-
-    boost::thread_group tg;
-    for (auto x = 0; x < nScriptCheckThreads; ++x) {
-       tg.create_thread([&]{fail_queue->Thread();});
-    }
+    auto fail_queue = std::make_unique<Failing_Queue>(QUEUE_BATCH_SIZE);
+    fail_queue->StartWorkerThreads(SCRIPT_CHECK_THREADS);
 
     for (size_t i = 0; i < 1001; ++i) {
         CCheckQueueControl<FailingCheck> control(fail_queue.get());
@@ -237,18 +225,14 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
             BOOST_REQUIRE(success);
         }
     }
-    tg.interrupt_all();
-    tg.join_all();
+    fail_queue->StopWorkerThreads();
 }
 // Test that a block validation which fails does not interfere with
 // future blocks, ie, the bad state is cleared.
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
 {
-    auto fail_queue = MakeUnique<Failing_Queue>(QUEUE_BATCH_SIZE);
-    boost::thread_group tg;
-    for (auto x = 0; x < nScriptCheckThreads; ++x) {
-       tg.create_thread([&]{fail_queue->Thread();});
-    }
+    auto fail_queue = std::make_unique<Failing_Queue>(QUEUE_BATCH_SIZE);
+    fail_queue->StartWorkerThreads(SCRIPT_CHECK_THREADS);
 
     for (auto times = 0; times < 10; ++times) {
         for (const bool end_fails : {true, false}) {
@@ -263,8 +247,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
             BOOST_REQUIRE(r != end_fails);
         }
     }
-    tg.interrupt_all();
-    tg.join_all();
+    fail_queue->StopWorkerThreads();
 }
 
 // Test that unique checks are actually all called individually, rather than
@@ -272,12 +255,8 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
 // more than once as well
 BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
 {
-    auto queue = MakeUnique<Unique_Queue>(QUEUE_BATCH_SIZE);
-    boost::thread_group tg;
-    for (auto x = 0; x < nScriptCheckThreads; ++x) {
-       tg.create_thread([&]{queue->Thread();});
-
-    }
+    auto queue = std::make_unique<Unique_Queue>(QUEUE_BATCH_SIZE);
+    queue->StartWorkerThreads(SCRIPT_CHECK_THREADS);
 
     size_t COUNT = 100000;
     size_t total = COUNT;
@@ -296,8 +275,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
     for (size_t i = 0; i < COUNT; ++i)
         r = r && UniqueCheck::results.count(i) == 1;
     BOOST_REQUIRE(r);
-    tg.interrupt_all();
-    tg.join_all();
+    queue->StopWorkerThreads();
 }
 
 
@@ -308,11 +286,8 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
 // time could leave the data hanging across a sequence of blocks.
 BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
 {
-    auto queue = MakeUnique<Memory_Queue>(QUEUE_BATCH_SIZE);
-    boost::thread_group tg;
-    for (auto x = 0; x < nScriptCheckThreads; ++x) {
-       tg.create_thread([&]{queue->Thread();});
-    }
+    auto queue = std::make_unique<Memory_Queue>(QUEUE_BATCH_SIZE);
+    queue->StartWorkerThreads(SCRIPT_CHECK_THREADS);
     for (size_t i = 0; i < 1000; ++i) {
         size_t total = i;
         {
@@ -331,20 +306,16 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
         }
         BOOST_REQUIRE_EQUAL(MemoryCheck::fake_allocated_memory, 0U);
     }
-    tg.interrupt_all();
-    tg.join_all();
+    queue->StopWorkerThreads();
 }
 
 // Test that a new verification cannot occur until all checks
 // have been destructed
 BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup)
 {
-    auto queue = MakeUnique<FrozenCleanup_Queue>(QUEUE_BATCH_SIZE);
-    boost::thread_group tg;
+    auto queue = std::make_unique<FrozenCleanup_Queue>(QUEUE_BATCH_SIZE);
     bool fails = false;
-    for (auto x = 0; x < nScriptCheckThreads; ++x) {
-        tg.create_thread([&]{queue->Thread();});
-    }
+    queue->StartWorkerThreads(SCRIPT_CHECK_THREADS);
     std::thread t0([&]() {
         CCheckQueueControl<FrozenCleanupCheck> control(queue.get());
         std::vector<FrozenCleanupCheck> vChecks(1);
@@ -363,7 +334,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup)
     }
     // Try to get control of the queue a bunch of times
     for (auto x = 0; x < 100 && !fails; ++x) {
-        fails = queue->ControlMutex.try_lock();
+        fails = queue->m_control_mutex.try_lock();
     }
     {
         // Unfreeze (we need lock n case of spurious wakeup)
@@ -374,35 +345,36 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup)
     FrozenCleanupCheck::cv.notify_one();
     // Wait for control to finish
     t0.join();
-    tg.interrupt_all();
-    tg.join_all();
     BOOST_REQUIRE(!fails);
+    queue->StopWorkerThreads();
 }
 
 
 /** Test that CCheckQueueControl is threadsafe */
 BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks)
 {
-    auto queue = MakeUnique<Standard_Queue>(QUEUE_BATCH_SIZE);
+    auto queue = std::make_unique<Standard_Queue>(QUEUE_BATCH_SIZE);
     {
-        boost::thread_group tg;
+        std::vector<std::thread> tg;
         std::atomic<int> nThreads {0};
         std::atomic<int> fails {0};
         for (size_t i = 0; i < 3; ++i) {
-            tg.create_thread(
+            tg.emplace_back(
                     [&]{
                     CCheckQueueControl<FakeCheck> control(queue.get());
                     // While sleeping, no other thread should execute to this point
                     auto observed = ++nThreads;
-                    MilliSleep(10);
+                    UninterruptibleSleep(std::chrono::milliseconds{10});
                     fails += observed  != nThreads;
                     });
         }
-        tg.join_all();
+        for (auto& thread: tg) {
+            if (thread.joinable()) thread.join();
+        }
         BOOST_REQUIRE_EQUAL(fails, 0);
     }
     {
-        boost::thread_group tg;
+        std::vector<std::thread> tg;
         std::mutex m;
         std::condition_variable cv;
         bool has_lock{false};
@@ -411,7 +383,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks)
         bool done_ack{false};
         {
             std::unique_lock<std::mutex> l(m);
-            tg.create_thread([&]{
+            tg.emplace_back([&]{
                     CCheckQueueControl<FakeCheck> control(queue.get());
                     std::unique_lock<std::mutex> ll(m);
                     has_lock = true;
@@ -427,7 +399,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks)
             cv.wait(l, [&](){return has_lock;});
             bool fails = false;
             for (auto x = 0; x < 100 && !fails; ++x) {
-                fails = queue->ControlMutex.try_lock();
+                fails = queue->m_control_mutex.try_lock();
             }
             has_tried = true;
             cv.notify_one();
@@ -437,7 +409,9 @@ BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks)
             cv.notify_one();
             BOOST_REQUIRE(!fails);
         }
-        tg.join_all();
+        for (auto& thread: tg) {
+            if (thread.joinable()) thread.join();
+        }
     }
 }
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/cuckoocache_tests.cpp b/src/test/cuckoocache_tests.cpp
index 67236344de..270198d64c 100644
--- a/src/test/cuckoocache_tests.cpp
+++ b/src/test/cuckoocache_tests.cpp
@@ -1,12 +1,18 @@
 // Copyright (c) 2012-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-#include <boost/test/unit_test.hpp>
 #include <cuckoocache.h>
 #include <script/sigcache.h>
 #include <test/setup_common.h>
 #include <random.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <deque>
+#include <mutex>
+#include <shared_mutex>
 #include <thread>
+#include <vector>
 
 /** Test Suite for CuckooCache
  *
@@ -198,11 +204,11 @@ static void test_cache_erase_parallel(size_t megabytes)
      * "future proofed".
      */
     std::vector<uint256> hashes_insert_copy = hashes;
-    boost::shared_mutex mtx;
+    std::shared_mutex mtx;
 
     {
         /** Grab lock to make sure we release inserts */
-        boost::unique_lock<boost::shared_mutex> l(mtx);
+        std::unique_lock<std::shared_mutex> l(mtx);
         /** Insert the first half */
         for (uint32_t i = 0; i < (n_insert / 2); ++i)
             set.insert(hashes_insert_copy[i]);
@@ -216,7 +222,7 @@ static void test_cache_erase_parallel(size_t megabytes)
         /** Each thread is emplaced with x copy-by-value
         */
         threads.emplace_back([&, x] {
-            boost::shared_lock<boost::shared_mutex> l(mtx);
+            std::shared_lock<std::shared_mutex> l(mtx);
             size_t ntodo = (n_insert/4)/3;
             size_t start = ntodo*x;
             size_t end = ntodo*(x+1);
@@ -231,7 +237,7 @@ static void test_cache_erase_parallel(size_t megabytes)
     for (std::thread& t : threads)
         t.join();
     /** Grab lock to make sure we observe erases */
-    boost::unique_lock<boost::shared_mutex> l(mtx);
+    std::unique_lock<std::shared_mutex> l(mtx);
     /** Insert the second half */
     for (uint32_t i = (n_insert / 2); i < n_insert; ++i)
         set.insert(hashes_insert_copy[i]);
diff --git a/src/test/dbwrapper_tests.cpp b/src/test/dbwrapper_tests.cpp
index 2ca4e82474..5073f82bdb 100644
--- a/src/test/dbwrapper_tests.cpp
+++ b/src/test/dbwrapper_tests.cpp
@@ -5,7 +5,6 @@
 #include <dbwrapper.h>
 #include <uint256.h>
 #include <test/setup_common.h>
-#include <util/memory.h>
 
 #include <memory>
 
@@ -127,7 +126,7 @@ BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
     create_directories(ph);
 
     // Set up a non-obfuscated wrapper to write some initial data.
-    std::unique_ptr<CDBWrapper> dbw = MakeUnique<CDBWrapper>(ph, (1 << 10), false, false, false);
+    std::unique_ptr<CDBWrapper> dbw = std::make_unique<CDBWrapper>(ph, (1 << 10), false, false, false);
     char key = 'k';
     uint256 in = InsecureRand256();
     uint256 res;
@@ -168,7 +167,7 @@ BOOST_AUTO_TEST_CASE(existing_data_reindex)
     create_directories(ph);
 
     // Set up a non-obfuscated wrapper to write some initial data.
-    std::unique_ptr<CDBWrapper> dbw = MakeUnique<CDBWrapper>(ph, (1 << 10), false, false, false);
+    std::unique_ptr<CDBWrapper> dbw = std::make_unique<CDBWrapper>(ph, (1 << 10), false, false, false);
     char key = 'k';
     uint256 in = InsecureRand256();
     uint256 res;
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index 8e31d110b5..40a2b65b7c 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -12,7 +12,6 @@
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <serialize.h>
-#include <util/memory.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
@@ -77,8 +76,8 @@ BOOST_FIXTURE_TEST_SUITE(denialofservice_tests, TestingSetup)
 // work.
 BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
 {
-    auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
-    auto peerLogic = MakeUnique<PeerLogicValidation>(connman.get(), nullptr, scheduler, false);
+    auto connman = std::make_unique<CConnman>(0x1337, 0x1337);
+    auto peerLogic = std::make_unique<PeerLogicValidation>(connman.get(), nullptr, scheduler, false);
 
     // Mock an outbound peer
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
@@ -208,9 +207,9 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
 
 BOOST_AUTO_TEST_CASE(DoS_banning)
 {
-    auto banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
-    auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
-    auto peerLogic = MakeUnique<PeerLogicValidation>(connman.get(), banman.get(), scheduler, false);
+    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    auto connman = std::make_unique<CConnman>(0x1337, 0x1337);
+    auto peerLogic = std::make_unique<PeerLogicValidation>(connman.get(), banman.get(), scheduler, false);
 
     banman->ClearBanned();
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
@@ -263,9 +262,9 @@ BOOST_AUTO_TEST_CASE(DoS_banning)
 
 BOOST_AUTO_TEST_CASE(DoS_banscore)
 {
-    auto banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
-    auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
-    auto peerLogic = MakeUnique<PeerLogicValidation>(connman.get(), banman.get(), scheduler, false);
+    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    auto connman = std::make_unique<CConnman>(0x1337, 0x1337);
+    auto peerLogic = std::make_unique<PeerLogicValidation>(connman.get(), banman.get(), scheduler, false);
 
     banman->ClearBanned();
     gArgs.ForceSetArg("-banscore", "111"); // because 11 is my favorite number
@@ -310,9 +309,9 @@ BOOST_AUTO_TEST_CASE(DoS_banscore)
 
 BOOST_AUTO_TEST_CASE(DoS_bantime)
 {
-    auto banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
-    auto connman = MakeUnique<CConnman>(0x1337, 0x1337);
-    auto peerLogic = MakeUnique<PeerLogicValidation>(connman.get(), banman.get(), scheduler, false);
+    auto banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    auto connman = std::make_unique<CConnman>(0x1337, 0x1337);
+    auto peerLogic = std::make_unique<PeerLogicValidation>(connman.get(), banman.get(), scheduler, false);
 
     banman->ClearBanned();
     int64_t nStartTime = GetTime();
diff --git a/src/test/fuzz/fuzz.cpp b/src/test/fuzz/fuzz.cpp
index b16fc441ba..7071eed2d3 100644
--- a/src/test/fuzz/fuzz.cpp
+++ b/src/test/fuzz/fuzz.cpp
@@ -7,7 +7,6 @@
 #include <unistd.h>
 
 #include <pubkey.h>
-#include <util/memory.h>
 
 
 static bool read_stdin(std::vector<uint8_t>& data)
@@ -24,7 +23,7 @@ static bool read_stdin(std::vector<uint8_t>& data)
 
 static void initialize()
 {
-    const static auto verify_handle = MakeUnique<ECCVerifyHandle>();
+    const static auto verify_handle = std::make_unique<ECCVerifyHandle>();
 }
 
 // This function is used by libFuzzer
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index 5210a6032b..2ec84a6e83 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -13,7 +13,6 @@
 #include <net.h>
 #include <netbase.h>
 #include <chainparams.h>
-#include <util/memory.h>
 #include <util/system.h>
 
 #include <memory>
@@ -183,12 +182,12 @@ BOOST_AUTO_TEST_CASE(cnode_simple_test)
     bool fInboundIn = false;
 
     // Test that fFeeler is false by default.
-    std::unique_ptr<CNode> pnode1 = MakeUnique<CNode>(id++, NODE_NETWORK, height, hSocket, addr, 0, 0, CAddress(), pszDest, fInboundIn);
+    std::unique_ptr<CNode> pnode1 = std::make_unique<CNode>(id++, NODE_NETWORK, height, hSocket, addr, 0, 0, CAddress(), pszDest, fInboundIn);
     BOOST_CHECK(pnode1->fInbound == false);
     BOOST_CHECK(pnode1->fFeeler == false);
 
     fInboundIn = true;
-    std::unique_ptr<CNode> pnode2 = MakeUnique<CNode>(id++, NODE_NETWORK, height, hSocket, addr, 1, 1, CAddress(), pszDest, fInboundIn);
+    std::unique_ptr<CNode> pnode2 = std::make_unique<CNode>(id++, NODE_NETWORK, height, hSocket, addr, 1, 1, CAddress(), pszDest, fInboundIn);
     BOOST_CHECK(pnode2->fInbound == true);
     BOOST_CHECK(pnode2->fFeeler == false);
 }
@@ -214,7 +213,7 @@ BOOST_AUTO_TEST_CASE(ipv4_peer_with_ipv6_addrMe_test)
     in_addr ipv4AddrPeer;
     ipv4AddrPeer.s_addr = 0xa0b0c001;
     CAddress addr = CAddress(CService(ipv4AddrPeer, 7777), NODE_NETWORK);
-    std::unique_ptr<CNode> pnode = MakeUnique<CNode>(0, NODE_NETWORK, 0, INVALID_SOCKET, addr, 0, 0, CAddress{}, std::string{}, false);
+    std::unique_ptr<CNode> pnode = std::make_unique<CNode>(0, NODE_NETWORK, 0, INVALID_SOCKET, addr, 0, 0, CAddress{}, std::string{}, false);
     pnode->fSuccessfullyConnected.store(true);
 
     // the peer claims to be reaching us via IPv6
diff --git a/src/test/oracles_tests.cpp b/src/test/oracles_tests.cpp
index 07c628f052..7ab5801e60 100644
--- a/src/test/oracles_tests.cpp
+++ b/src/test/oracles_tests.cpp
@@ -3,15 +3,14 @@
 // file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/setup_common.h>
-#include <string>
+
 #include <boost/test/unit_test.hpp>
 
 #include <masternodes/oracles.h>
 #include <rpc/rawtransaction_util.h>
 #include <masternodes/masternodes.h>
 
-#include <boost/algorithm/string/join.hpp>
-#include <boost/range/adaptor/transformed.hpp>
+#include <string>
 
 struct OraclesTestingSetup : public TestingSetup {
     const std::string data1 =
@@ -22,20 +21,9 @@ struct OraclesTestingSetup : public TestingSetup {
             "\x9c\x52\x4a\xac\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
             "\x22\x81\xaa\xb5\x24\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
 
-    const std::string hex1 = "7d1de5eaf9b156d53208f033b5aa8122d2d2355d5e12292b121156cfdb4a529c";
     const std::vector<unsigned char> rawVector1{data1.begin(), data1.end()};
     const std::vector<unsigned char> rawVector2{data2.begin(), data2.end()};
-    const std::string address1 = "mhWzxsS5aDfmNY2EpPuM2xQZx7Ju3yjkQ4";
-
-    std::string JoinOracles(const std::vector<COracleId> &oracles) {
-        auto list = boost::algorithm::join(
-                oracles | boost::adaptors::transformed(
-                        [](const COracleId &x) -> std::string {
-                            return x.GetHex();
-                        }),
-                ", ");
-        return "[" + list + "]";
-    }
+
 };
 
 BOOST_FIXTURE_TEST_SUITE(oracles_tests, OraclesTestingSetup)
@@ -113,7 +101,6 @@ BOOST_FIXTURE_TEST_SUITE(oracles_tests, OraclesTestingSetup)
     BOOST_AUTO_TEST_CASE(update_oracle_test) {
 
         COracleId oracleId1{rawVector1};
-        COracleId oracleId2{rawVector2};
         uint8_t weightage = 15;
         std::vector<unsigned char> tmp{'a', 'b', 'c'};
         CScript oracleAddress1{tmp.begin(), tmp.end()};
diff --git a/src/test/reverselock_tests.cpp b/src/test/reverselock_tests.cpp
index 5d424df275..212f5a747e 100644
--- a/src/test/reverselock_tests.cpp
+++ b/src/test/reverselock_tests.cpp
@@ -11,21 +11,50 @@ BOOST_FIXTURE_TEST_SUITE(reverselock_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(reverselock_basics)
 {
-    boost::mutex mutex;
-    boost::unique_lock<boost::mutex> lock(mutex);
+    Mutex mutex;
+    std::unique_lock<std::mutex> lock(mutex);
 
     BOOST_CHECK(lock.owns_lock());
     {
-        reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+        reverse_lock<std::unique_lock<std::mutex>> rlock(lock);
         BOOST_CHECK(!lock.owns_lock());
     }
     BOOST_CHECK(lock.owns_lock());
 }
 
+BOOST_AUTO_TEST_CASE(reverselock_multiple)
+{
+    Mutex mutex2;
+    Mutex mutex;
+    std::unique_lock<std::mutex> lock2(mutex2);
+    std::unique_lock<std::mutex> lock(mutex);
+
+    // Make sure undoing two locks succeeds
+    {
+        reverse_lock<std::unique_lock<std::mutex>> rlock(lock);
+        BOOST_CHECK(!lock.owns_lock());
+        reverse_lock<std::unique_lock<std::mutex>> rlock2(lock2);
+        BOOST_CHECK(!lock2.owns_lock());
+    }
+    BOOST_CHECK(lock.owns_lock());
+    BOOST_CHECK(lock2.owns_lock());
+}
+
 BOOST_AUTO_TEST_CASE(reverselock_errors)
 {
-    boost::mutex mutex;
-    boost::unique_lock<boost::mutex> lock(mutex);
+    Mutex mutex2;
+    Mutex mutex;
+    std::unique_lock<std::mutex> lock2(mutex2);
+    std::unique_lock<std::mutex> lock(mutex);
+
+#ifdef DEBUG_LOCKORDER
+        // Make sure trying to reverse lock a previous lock fails
+    try {
+        reverse_lock<std::unique_lock<std::mutex>> rlock2(lock2);
+        BOOST_CHECK(false); // REVERSE_LOCK(lock2) succeeded
+    } catch(...) { }
+    BOOST_CHECK(lock2.owns_lock());
+#endif
 
     // Make sure trying to reverse lock an unlocked lock fails
     lock.unlock();
@@ -34,7 +63,7 @@ BOOST_AUTO_TEST_CASE(reverselock_errors)
 
     bool failed = false;
     try {
-        reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+        reverse_lock<std::unique_lock<std::mutex>> rlock(lock);
     } catch(...) {
         failed = true;
     }
@@ -49,7 +78,7 @@ BOOST_AUTO_TEST_CASE(reverselock_errors)
     lock.lock();
     BOOST_CHECK(lock.owns_lock());
     {
-        reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+        reverse_lock<std::unique_lock<std::mutex>> rlock(lock);
         BOOST_CHECK(!lock.owns_lock());
     }
 
diff --git a/src/test/scheduler_tests.cpp b/src/test/scheduler_tests.cpp
index 9a18ad2b3a..622b459939 100644
--- a/src/test/scheduler_tests.cpp
+++ b/src/test/scheduler_tests.cpp
@@ -4,39 +4,31 @@
 
 #include <random.h>
 #include <scheduler.h>
+#include <util/time.h>
 
 #include <test/setup_common.h>
 
-#include <boost/thread.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include <mutex>
+#include <thread>
+#include <vector>
+
 BOOST_AUTO_TEST_SUITE(scheduler_tests)
 
-static void microTask(CScheduler& s, boost::mutex& mutex, int& counter, int delta, boost::chrono::system_clock::time_point rescheduleTime)
+static void microTask(CScheduler& s, std::mutex& mutex, int& counter, int delta, std::chrono::system_clock::time_point rescheduleTime)
 {
     {
-        boost::unique_lock<boost::mutex> lock(mutex);
+        std::lock_guard<std::mutex> lock(mutex);
         counter += delta;
     }
-    boost::chrono::system_clock::time_point noTime = boost::chrono::system_clock::time_point::min();
+    std::chrono::system_clock::time_point noTime = std::chrono::system_clock::time_point::min();
     if (rescheduleTime != noTime) {
         CScheduler::Function f = std::bind(&microTask, std::ref(s), std::ref(mutex), std::ref(counter), -delta + 1, noTime);
         s.schedule(f, rescheduleTime);
     }
 }
 
-static void MicroSleep(uint64_t n)
-{
-#if defined(HAVE_WORKING_BOOST_SLEEP_FOR)
-    boost::this_thread::sleep_for(boost::chrono::microseconds(n));
-#elif defined(HAVE_WORKING_BOOST_SLEEP)
-    boost::this_thread::sleep(boost::posix_time::microseconds(n));
-#else
-    //should never get here
-    #error missing boost sleep implementation
-#endif
-}
-
 BOOST_AUTO_TEST_CASE(manythreads)
 {
     // Stress test: hundreds of microsecond-scheduled tasks,
@@ -51,22 +43,22 @@ BOOST_AUTO_TEST_CASE(manythreads)
     // counters should sum to the number of initial tasks performed.
     CScheduler microTasks;
 
-    boost::mutex counterMutex[10];
+    std::mutex counterMutex[10];
     int counter[10] = { 0 };
     FastRandomContext rng{/* fDeterministic */ true};
     auto zeroToNine = [](FastRandomContext& rc) -> int { return rc.randrange(10); }; // [0, 9]
     auto randomMsec = [](FastRandomContext& rc) -> int { return -11 + (int)rc.randrange(1012); }; // [-11, 1000]
     auto randomDelta = [](FastRandomContext& rc) -> int { return -1000 + (int)rc.randrange(2001); }; // [-1000, 1000]
 
-    boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
-    boost::chrono::system_clock::time_point now = start;
-    boost::chrono::system_clock::time_point first, last;
+    std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
+    std::chrono::system_clock::time_point now = start;
+    std::chrono::system_clock::time_point first, last;
     size_t nTasks = microTasks.getQueueInfo(first, last);
     BOOST_CHECK(nTasks == 0);
 
     for (int i = 0; i < 100; ++i) {
-        boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
-        boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
+        std::chrono::system_clock::time_point t = now + std::chrono::microseconds(randomMsec(rng));
+        std::chrono::system_clock::time_point tReschedule = now + std::chrono::microseconds(500 + randomMsec(rng));
         int whichCounter = zeroToNine(rng);
         CScheduler::Function f = std::bind(&microTask, std::ref(microTasks),
                                              std::ref(counterMutex[whichCounter]), std::ref(counter[whichCounter]),
@@ -79,19 +71,19 @@ BOOST_AUTO_TEST_CASE(manythreads)
     BOOST_CHECK(last > now);
 
     // As soon as these are created they will start running and servicing the queue
-    boost::thread_group microThreads;
+    std::vector<std::thread> microThreads;
     for (int i = 0; i < 5; i++)
-        microThreads.create_thread(std::bind(&CScheduler::serviceQueue, &microTasks));
+        microThreads.emplace_back(std::bind(&CScheduler::serviceQueue, &microTasks));
 
-    MicroSleep(600);
-    now = boost::chrono::system_clock::now();
+    UninterruptibleSleep(std::chrono::microseconds{600});
+    now = std::chrono::system_clock::now();
 
     // More threads and more tasks:
     for (int i = 0; i < 5; i++)
-        microThreads.create_thread(std::bind(&CScheduler::serviceQueue, &microTasks));
+        microThreads.emplace_back(std::bind(&CScheduler::serviceQueue, &microTasks));
     for (int i = 0; i < 100; i++) {
-        boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
-        boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
+        std::chrono::system_clock::time_point t = now + std::chrono::microseconds(randomMsec(rng));
+        std::chrono::system_clock::time_point tReschedule = now + std::chrono::microseconds(500 + randomMsec(rng));
         int whichCounter = zeroToNine(rng);
         CScheduler::Function f = std::bind(&microTask, std::ref(microTasks),
                                              std::ref(counterMutex[whichCounter]), std::ref(counter[whichCounter]),
@@ -100,8 +92,11 @@ BOOST_AUTO_TEST_CASE(manythreads)
     }
 
     // Drain the task queue then exit threads
-    microTasks.stop(true);
-    microThreads.join_all(); // ... wait until all the threads are done
+    microTasks.StopWhenDrained();
+    // wait until all the threads are done
+    for (auto& thread: microThreads) {
+        if (thread.joinable()) thread.join();
+    }
 
     int counterSum = 0;
     for (int i = 0; i < 10; i++) {
@@ -123,9 +118,9 @@ BOOST_AUTO_TEST_CASE(singlethreadedscheduler_ordered)
     // if the queues only permit execution of one task at once then
     // the extra threads should effectively be doing nothing
     // if they don't we'll get out of order behaviour
-    boost::thread_group threads;
+    std::vector<std::thread> threads;
     for (int i = 0; i < 5; ++i) {
-        threads.create_thread(std::bind(&CScheduler::serviceQueue, &scheduler));
+        threads.emplace_back(std::bind(&CScheduler::serviceQueue, &scheduler));
     }
 
     // these are not atomic, if SinglethreadedSchedulerClient prevents
@@ -148,8 +143,10 @@ BOOST_AUTO_TEST_CASE(singlethreadedscheduler_ordered)
     }
 
     // finish up
-    scheduler.stop(true);
-    threads.join_all();
+    scheduler.StopWhenDrained();
+    for (auto& thread: threads) {
+        if (thread.joinable()) thread.join();
+    }
 
     BOOST_CHECK_EQUAL(counter1, 100);
     BOOST_CHECK_EQUAL(counter2, 100);
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index 9362c577a4..3ba8c2ea4a 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -177,23 +177,23 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     s.clear();
     s << ToByteVector(pubkey) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<PKHash>(&address) &&
-                *boost::get<PKHash>(&address) == PKHash(pubkey));
+    BOOST_CHECK(std::get_if<PKHash>(&address) &&
+                *std::get_if<PKHash>(&address) == PKHash(pubkey));
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<PKHash>(&address) &&
-                *boost::get<PKHash>(&address) == PKHash(pubkey));
+    BOOST_CHECK(std::get_if<PKHash>(&address) &&
+                *std::get_if<PKHash>(&address) == PKHash(pubkey));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<ScriptHash>(&address) &&
-                *boost::get<ScriptHash>(&address) == ScriptHash(redeemScript));
+    BOOST_CHECK(std::get_if<ScriptHash>(&address) &&
+                *std::get_if<ScriptHash>(&address) == ScriptHash(redeemScript));
 
     // TX_MULTISIG
     s.clear();
@@ -211,7 +211,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     BOOST_CHECK(ExtractDestination(s, address));
     WitnessV0KeyHash keyhash;
     CHash160().Write(pubkey.begin(), pubkey.size()).Finalize(keyhash.begin());
-    BOOST_CHECK(boost::get<WitnessV0KeyHash>(&address) && *boost::get<WitnessV0KeyHash>(&address) == keyhash);
+    BOOST_CHECK(std::get_if<WitnessV0KeyHash>(&address) && *std::get_if<WitnessV0KeyHash>(&address) == keyhash);
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
@@ -219,7 +219,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     CSHA256().Write(redeemScript.data(), redeemScript.size()).Finalize(scripthash.begin());
     s << OP_0 << ToByteVector(scripthash);
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<WitnessV0ScriptHash>(&address) && *boost::get<WitnessV0ScriptHash>(&address) == scripthash);
+    BOOST_CHECK(std::get_if<WitnessV0ScriptHash>(&address) && *std::get_if<WitnessV0ScriptHash>(&address) == scripthash);
 
     // TX_WITNESS with unknown version
     s.clear();
@@ -229,7 +229,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     unk.length = 33;
     unk.version = 1;
     std::copy(pubkey.begin(), pubkey.end(), unk.program);
-    BOOST_CHECK(boost::get<WitnessUnknown>(&address) && *boost::get<WitnessUnknown>(&address) == unk);
+    BOOST_CHECK(std::get_if<WitnessUnknown>(&address) && *std::get_if<WitnessUnknown>(&address) == unk);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
@@ -253,8 +253,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
-                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
+    BOOST_CHECK(std::get_if<PKHash>(&addresses[0]) &&
+                *std::get_if<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
 
     // TX_PUBKEYHASH
     s.clear();
@@ -263,8 +263,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
-                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
+    BOOST_CHECK(std::get_if<PKHash>(&addresses[0]) &&
+                *std::get_if<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
@@ -274,8 +274,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<ScriptHash>(&addresses[0]) &&
-                *boost::get<ScriptHash>(&addresses[0]) == ScriptHash(redeemScript));
+    BOOST_CHECK(std::get_if<ScriptHash>(&addresses[0]) &&
+                *std::get_if<ScriptHash>(&addresses[0]) == ScriptHash(redeemScript));
 
     // TX_MULTISIG
     s.clear();
@@ -287,10 +287,10 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(addresses.size(), 2U);
     BOOST_CHECK_EQUAL(nRequired, 2);
-    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
-                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
-    BOOST_CHECK(boost::get<PKHash>(&addresses[1]) &&
-                *boost::get<PKHash>(&addresses[1]) == PKHash(pubkeys[1]));
+    BOOST_CHECK(std::get_if<PKHash>(&addresses[0]) &&
+                *std::get_if<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
+    BOOST_CHECK(std::get_if<PKHash>(&addresses[1]) &&
+                *std::get_if<PKHash>(&addresses[1]) == PKHash(pubkeys[1]));
 
     // TX_NULL_DATA
     s.clear();
diff --git a/src/test/setup_common.cpp b/src/test/setup_common.cpp
index 7ddf50526d..a79f7acd6a 100644
--- a/src/test/setup_common.cpp
+++ b/src/test/setup_common.cpp
@@ -23,7 +23,6 @@
 #include <script/sigcache.h>
 #include <streams.h>
 #include <txdb.h>
-#include <util/memory.h>
 #include <util/strencodings.h>
 #include <util/time.h>
 #include <util/translation.h>
@@ -97,12 +96,12 @@ TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(cha
 
     // We have to run a scheduler thread to prevent ActivateBestChain
     // from blocking due to queue overrun.
-    threadGroup.create_thread(std::bind(&CScheduler::serviceQueue, &scheduler));
+    scheduler.m_service_thread = std::thread([&] { TraceThread("scheduler", [&] { scheduler.serviceQueue(); }); });
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
 
     mempool.setSanityCheck(1.0);
     pblocktree.reset(new CBlockTreeDB(1 << 20, true));
-    g_chainstate = MakeUnique<CChainState>();
+    g_chainstate = std::make_unique<CChainState>();
     ::ChainstateActive().InitCoinsDB(
         /* cache_size_bytes */ 1 << 23, /* in_memory */ true, /* should_wipe */ false);
     assert(!::ChainstateActive().CanFlushToDisk());
@@ -113,15 +112,15 @@ TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(cha
         LOCK(cs_main);
 
         pcustomcsDB.reset();
-        pcustomcsDB = MakeUnique<CStorageLevelDB>(GetDataDir() / "enhancedcs", nMinDbCache << 20, true, true);
-        pcustomcsview = MakeUnique<CCustomCSView>(*pcustomcsDB.get());
+        pcustomcsDB = std::make_unique<CStorageLevelDB>(GetDataDir() / "enhancedcs", nMinDbCache << 20, true, true);
+        pcustomcsview = std::make_unique<CCustomCSView>(*pcustomcsDB.get());
 
         panchorauths.reset();
-        panchorauths = MakeUnique<CAnchorAuthIndex>();
+        panchorauths = std::make_unique<CAnchorAuthIndex>();
         panchorAwaitingConfirms.reset();
-        panchorAwaitingConfirms = MakeUnique<CAnchorAwaitingConfirms>();
+        panchorAwaitingConfirms = std::make_unique<CAnchorAwaitingConfirms>();
         panchors.reset();
-        panchors = MakeUnique<CAnchorIndex>(nMinDbCache << 20, true, true);
+        panchors = std::make_unique<CAnchorIndex>(nMinDbCache << 20, true, true);
         panchors->Load();
     }
 
@@ -134,18 +133,18 @@ TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(cha
         throw std::runtime_error(strprintf("ActivateBestChain failed. (%s)", FormatStateMessage(state)));
     }
 
-    nScriptCheckThreads = 3;
-    for (int i = 0; i < nScriptCheckThreads - 1; i++)
-        threadGroup.create_thread([i]() { return ThreadScriptCheck(i); });
+    constexpr int script_check_threads = 2;
+    StartScriptCheckWorkerThreads(script_check_threads);
+    g_parallel_script_checks = true;
 
-    g_banman = MakeUnique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
-    g_connman = MakeUnique<CConnman>(0x1337, 0x1337); // Deterministic randomness for tests.
+    g_banman = std::make_unique<BanMan>(GetDataDir() / "banlist.dat", nullptr, DEFAULT_MISBEHAVING_BANTIME);
+    g_connman = std::make_unique<CConnman>(0x1337, 0x1337); // Deterministic randomness for tests.
 }
 
 TestingSetup::~TestingSetup()
 {
-    threadGroup.interrupt_all();
-    threadGroup.join_all();
+    scheduler.stop();
+    StopScriptCheckWorkerThreads();
     GetMainSignals().FlushBackgroundCallbacks();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     g_connman.reset();
diff --git a/src/test/setup_common.h b/src/test/setup_common.h
index 82aef59de5..8513402a2f 100644
--- a/src/test/setup_common.h
+++ b/src/test/setup_common.h
@@ -14,8 +14,7 @@
 #include <txmempool.h>
 
 #include <type_traits>
-
-#include <boost/thread.hpp>
+#include <vector>
 
 // Enable BOOST_CHECK_EQUAL for enum class types
 template <typename T>
@@ -73,7 +72,6 @@ struct BasicTestingSetup {
  * Included are coins database, script check threads setup.
  */
 struct TestingSetup : public BasicTestingSetup {
-    boost::thread_group threadGroup;
     CScheduler scheduler;
 
     explicit TestingSetup(const std::string& chainName = CBaseChainParams::MAIN);
diff --git a/src/test/storage_tests.cpp b/src/test/storage_tests.cpp
index 601ac297e6..fef729b804 100644
--- a/src/test/storage_tests.cpp
+++ b/src/test/storage_tests.cpp
@@ -1,10 +1,8 @@
 #include <rpc/server.h>
 #include <rpc/client.h>
-#include <rpc/util.h>
 
 #include <interfaces/chain.h>
 #include <key_io.h>
-#include <masternodes/accountshistory.h>
 #include <masternodes/masternodes.h>
 #include <rpc/rawtransaction_util.h>
 #include <test/setup_common.h>
@@ -64,8 +62,6 @@ std::map<TBytes, TBytes> TakeSnapshot(CStorageKV const & storage)
     TBytes key;
     auto it = const_cast<CStorageKV&>(storage).NewIterator();
     for(it->Seek(key); it->Valid(); it->Next()) {
-        boost::this_thread::interruption_point();
-
         result.emplace(it->Key(),it->Value());
     }
     return result;
@@ -100,7 +96,7 @@ BOOST_AUTO_TEST_CASE(undo)
     auto undo = CUndo::Construct(base_raw, flushable.GetRaw());
     BOOST_CHECK(undo.before.size() == 2);
     BOOST_CHECK(undo.before.at(ToBytes("testkey1")) == ToBytes("value0"));
-    BOOST_CHECK(undo.before.at(ToBytes("testkey2")).is_initialized() == false);
+    BOOST_CHECK(undo.before.at(ToBytes("testkey2")).has_value() == false);
 
     // flush changes
     mnview.Flush();
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 039d6811fc..c1fda18ec9 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -464,12 +464,10 @@ BOOST_AUTO_TEST_CASE(test_big_witness_transaction)
 
     // check all inputs concurrently, with the cache
     PrecomputedTransactionData txdata(tx);
-    boost::thread_group threadGroup;
     CCheckQueue<CScriptCheck> scriptcheckqueue(128);
     CCheckQueueControl<CScriptCheck> control(&scriptcheckqueue);
 
-    for (int i=0; i<20; i++)
-        threadGroup.create_thread(std::bind(&CCheckQueue<CScriptCheck>::Thread, std::ref(scriptcheckqueue)));
+    scriptcheckqueue.StartWorkerThreads(20);
 
     std::vector<Coin> coins;
     for(uint32_t i = 0; i < mtx.vin.size(); i++) {
@@ -492,8 +490,7 @@ BOOST_AUTO_TEST_CASE(test_big_witness_transaction)
     bool controlCheck = control.Wait();
     assert(controlCheck);
 
-    threadGroup.interrupt_all();
-    threadGroup.join_all();
+    scriptcheckqueue.StopWorkerThreads();
 }
 
 SignatureData CombineSignatures(const CMutableTransaction& input1, const CMutableTransaction& input2, const CTransactionRef tx)
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index fb718f1490..2cc6ced6bb 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -1110,7 +1110,7 @@ BOOST_AUTO_TEST_CASE(util_time_GetTime)
     SetMockTime(111);
     // Check that mock time does not change after a sleep
     for (const auto& num_sleep : {0, 1}) {
-        MilliSleep(num_sleep);
+        UninterruptibleSleep(std::chrono::milliseconds{num_sleep});
         BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
         BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
         BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
@@ -1121,7 +1121,7 @@ BOOST_AUTO_TEST_CASE(util_time_GetTime)
     // Check that system time changes after a sleep
     const auto ms_0 = GetTime<std::chrono::milliseconds>();
     const auto us_0 = GetTime<std::chrono::microseconds>();
-    MilliSleep(1);
+    UninterruptibleSleep(std::chrono::milliseconds{1});
     BOOST_CHECK(ms_0 < GetTime<std::chrono::milliseconds>());
     BOOST_CHECK(us_0 < GetTime<std::chrono::microseconds>());
 }
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 1a6a939d2b..e449384010 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -16,8 +16,6 @@
 
 #include <stdint.h>
 
-#include <boost/thread.hpp>
-
 static const char DB_COIN = 'C';
 static const char DB_COINS = 'c';
 static const char DB_BLOCK_FILES = 'f';
@@ -254,7 +252,6 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
 
     // Load m_block_index
     while (pcursor->Valid()) {
-        boost::this_thread::interruption_point();
         if (ShutdownRequested()) return false;
         std::pair<char, uint256> key;
         if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
@@ -379,7 +376,6 @@ bool CCoinsViewDB::Upgrade() {
     std::pair<unsigned char, uint256> key;
     std::pair<unsigned char, uint256> prev_key = {DB_COINS, uint256()};
     while (pcursor->Valid()) {
-        boost::this_thread::interruption_point();
         if (ShutdownRequested()) {
             break;
         }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index e3686020c9..9b8151eae5 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -157,7 +157,7 @@ bool CTxMemPool::CalculateMemPoolAncestors(const CTxMemPoolEntry &entry, setEntr
         // GetMemPoolParents() is only valid for entries in the mempool, so we
         // iterate mapTx to find parents.
         for (unsigned int i = 0; i < tx.vin.size(); i++) {
-            boost::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
+            std::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
             if (piter) {
                 parentHashes.insert(*piter);
                 if (parentHashes.size() + 1 > limitAncestorCount) {
@@ -558,7 +558,7 @@ CCustomCSView& CTxMemPool::accountsView()
 {
     if (!acview) {
         assert(pcustomcsview);
-        acview = MakeUnique<CCustomCSView>(*pcustomcsview);
+        acview = std::make_unique<CCustomCSView>(*pcustomcsview);
     }
     return *acview;
 }
@@ -923,11 +923,11 @@ const CTransaction* CTxMemPool::GetConflictTx(const COutPoint& prevout) const
     return it == mapNextTx.end() ? nullptr : it->second;
 }
 
-boost::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const uint256& txid) const
+std::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const uint256& txid) const
 {
     auto it = mapTx.find(txid);
     if (it != mapTx.end()) return it;
-    return boost::optional<txiter>{};
+    return {};
 }
 
 CTxMemPool::setEntries CTxMemPool::GetIterSet(const std::set<uint256>& hashes) const
diff --git a/src/txmempool.h b/src/txmempool.h
index 264e5f0b41..41d5f0b143 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -605,7 +605,7 @@ class CTxMemPool
     const CTransaction* GetConflictTx(const COutPoint& prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /** Returns an iterator to the given hash, if found */
-    boost::optional<txiter> GetIter(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    std::optional<txiter> GetIter(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /** Translate a set of hashes into a set of pool iterators to avoid repeated lookups */
     setEntries GetIterSet(const std::set<uint256>& hashes) const EXCLUSIVE_LOCKS_REQUIRED(cs);
diff --git a/src/util/memory.h b/src/util/memory.h
deleted file mode 100644
index 08da504ef1..0000000000
--- a/src/util/memory.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2018 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef DEFI_UTIL_MEMORY_H
-#define DEFI_UTIL_MEMORY_H
-
-#include <memory>
-#include <utility>
-
-//! Substitute for C++14 std::make_unique.
-template <typename T, typename... Args>
-std::unique_ptr<T> MakeUnique(Args&&... args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-#endif
diff --git a/src/util/system.cpp b/src/util/system.cpp
index ffafb762c3..20ac993c11 100644
--- a/src/util/system.cpp
+++ b/src/util/system.cpp
@@ -94,7 +94,7 @@ bool LockDirectory(const fs::path& directory, const std::string lockfile_name, b
     // Create empty lock file if it doesn't exist.
     FILE* file = fsbridge::fopen(pathLockFile, "a");
     if (file) fclose(file);
-    auto lock = MakeUnique<fsbridge::FileLock>(pathLockFile);
+    auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
     if (!lock->TryLock()) {
         return error("Error while attempting to lock directory %s: %s", directory.string(), lock->GetReason());
     }
diff --git a/src/util/system.h b/src/util/system.h
index b616c9b56d..f7d5f7c781 100644
--- a/src/util/system.h
+++ b/src/util/system.h
@@ -21,7 +21,6 @@
 #include <logging.h>
 #include <sync.h>
 #include <tinyformat.h>
-#include <util/memory.h>
 #include <util/threadnames.h>
 #include <util/time.h>
 
@@ -33,8 +32,6 @@
 #include <utility>
 #include <vector>
 
-#include <boost/thread/condition_variable.hpp> // for boost::thread_interrupted
-
 // Application startup time (used for uptime calculation)
 int64_t GetStartupTime();
 
@@ -346,11 +343,6 @@ template <typename Callable> void TraceThread(const char* name,  Callable func)
         func();
         LogPrintf("%s thread exit\n", name);
     }
-    catch (const boost::thread_interrupted&)
-    {
-        LogPrintf("%s thread interrupt\n", name);
-        throw;
-    }
     catch (const std::exception& e) {
         PrintExceptionContinue(&e, name);
         throw;
diff --git a/src/util/time.cpp b/src/util/time.cpp
index 2482789562..7967a736f0 100644
--- a/src/util/time.cpp
+++ b/src/util/time.cpp
@@ -11,10 +11,13 @@
 
 #include <atomic>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/thread.hpp>
 #include <ctime>
+#include <thread>
+
 #include <tinyformat.h>
 
+void UninterruptibleSleep(const std::chrono::microseconds& n) { std::this_thread::sleep_for(n); }
+
 static std::atomic<int64_t> nMockTime(0); //!< For unit testing
 
 int64_t GetTime()
@@ -72,24 +75,6 @@ int64_t GetSystemTimeInSeconds()
     return GetTimeMicros()/1000000;
 }
 
-void MilliSleep(int64_t n)
-{
-
-/**
- * Boost's sleep_for was uninterruptible when backed by nanosleep from 1.50
- * until fixed in 1.52. Use the deprecated sleep method for the broken case.
- * See: https://svn.boost.org/trac/boost/ticket/7238
- */
-#if defined(HAVE_WORKING_BOOST_SLEEP_FOR)
-    boost::this_thread::sleep_for(boost::chrono::milliseconds(n));
-#elif defined(HAVE_WORKING_BOOST_SLEEP)
-    boost::this_thread::sleep(boost::posix_time::milliseconds(n));
-#else
-//should never get here
-#error missing boost sleep implementation
-#endif
-}
-
 std::string FormatISO8601DateTime(int64_t nTime) {
     struct tm ts;
     time_t time_val = nTime;
diff --git a/src/util/time.h b/src/util/time.h
index 9c1da50e65..63adbef464 100644
--- a/src/util/time.h
+++ b/src/util/time.h
@@ -10,6 +10,8 @@
 #include <string>
 #include <chrono>
 
+void UninterruptibleSleep(const std::chrono::microseconds& n);
+
 /**
  * DEPRECATED
  * Use either GetSystemTimeInSeconds (not mockable) or GetTime<T> (mockable)
@@ -28,8 +30,6 @@ void SetMockTime(int64_t nMockTimeIn);
 /** For testing */
 int64_t GetMockTime();
 
-void MilliSleep(int64_t n);
-
 /** Return system time (or mocked time, if set) */
 template <typename T>
 T GetTime();
diff --git a/src/validation.cpp b/src/validation.cpp
index 2ff3ad4634..a3fb2327fd 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -58,11 +58,9 @@
 #include <net_processing.h>
 
 #include <future>
-#include <sstream>
 #include <string>
 
 #include <boost/algorithm/string/replace.hpp>
-#include <boost/thread.hpp>
 
 #if defined(NDEBUG)
 # error "Defi cannot be compiled without assertions."
@@ -124,7 +122,7 @@ CBlockIndex *pindexBestHeader = nullptr;
 Mutex g_best_block_mutex;
 std::condition_variable g_best_block_cv;
 uint256 g_best_block;
-int nScriptCheckThreads = 0;
+bool g_parallel_script_checks{false};
 std::atomic_bool fImporting(false);
 std::atomic_bool fReindex(false);
 bool fHavePruned = false;
@@ -1173,7 +1171,7 @@ CoinsViews::CoinsViews(
 
 void CoinsViews::InitCache()
 {
-    m_cacheview = MakeUnique<CCoinsViewCache>(&m_catcherview);
+    m_cacheview = std::make_unique<CCoinsViewCache>(&m_catcherview);
 }
 
 // NOTE: for now m_blockman is set to a global, but this will be changed
@@ -1187,7 +1185,7 @@ void CChainState::InitCoinsDB(
     bool should_wipe,
     std::string leveldb_name)
 {
-    m_coins_views = MakeUnique<CoinsViews>(
+    m_coins_views = std::make_unique<CoinsViews>(
         leveldb_name, cache_size_bytes, in_memory, should_wipe);
 }
 
@@ -1675,8 +1673,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
     ReverseGeneralCoinbaseTx(mnview, pindex->nHeight);
 
     CKeyID minterKey;
-    boost::optional<uint256> nodeId;
-    boost::optional<CMasternode> node;
+    std::optional<uint256> nodeId;
 
     if (!fIsFakeNet) {
         minterKey = pindex->minterKey();
@@ -1873,9 +1870,14 @@ static bool WriteUndoDataForBlock(const CBlockUndo& blockundo, CValidationState&
 
 static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
 
-void ThreadScriptCheck(int worker_num) {
-    util::ThreadRename(strprintf("scriptch.%i", worker_num));
-    scriptcheckqueue.Thread();
+void StartScriptCheckWorkerThreads(int threads_num)
+{
+    scriptcheckqueue.StartWorkerThreads(threads_num);
+}
+
+void StopScriptCheckWorkerThreads()
+{
+    scriptcheckqueue.StopWorkerThreads();
 }
 
 VersionBitsCache versionbitscache GUARDED_BY(cs_main);
@@ -2301,8 +2303,8 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     }
 
     CKeyID minterKey;
-    boost::optional<uint256> nodeId;
-    boost::optional<CMasternode> nodePtr;
+    std::optional<uint256> nodeId;
+    std::optional<CMasternode> nodePtr;
 
     // We are forced not to check this due to the block wasn't signed yet if called by TestBlockValidity()
     if (!fJustCheck && !fIsFakeNet) {
@@ -2464,7 +2466,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
 
     CBlockUndo blockundo;
 
-    CCheckQueueControl<CScriptCheck> control(fScriptChecks && nScriptCheckThreads ? &scriptcheckqueue : nullptr);
+    CCheckQueueControl<CScriptCheck> control(fScriptChecks && g_parallel_script_checks ? &scriptcheckqueue : nullptr);
 
     std::vector<std::pair<AccountHistoryKey, AccountHistoryValue>> writeBurnEntries;
     std::vector<int> prevheights;
@@ -2531,7 +2533,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
         {
             std::vector<CScriptCheck> vChecks;
             bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
-            if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults, fCacheResults, txdata[i], nScriptCheckThreads ? &vChecks : nullptr)) {
+            if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults, fCacheResults, txdata[i], g_parallel_script_checks ? &vChecks : nullptr)) {
                 if (state.GetReason() == ValidationInvalidReason::TX_NOT_STANDARD) {
                     // CheckInputs may return NOT_STANDARD for extra flags we passed,
                     // but we can't return that, as it's not defined for a block, so
@@ -3863,8 +3865,6 @@ bool CChainState::ActivateBestChainStep(CValidationState& state, const CChainPar
     DisconnectedBlockTransactions disconnectpool;
     auto disconnectBlocksTo = [&](const CBlockIndex *pindex) -> bool {
         while (m_chain.Tip() && m_chain.Tip() != pindex) {
-            boost::this_thread::interruption_point();
-
             if (!DisconnectTip(state, chainparams, &disconnectpool)) {
                 // This is likely a fatal error, but keep the mempool consistent,
                 // just in case. Only remove from the mempool in this case.
@@ -4047,8 +4047,6 @@ bool CChainState::ActivateBestChain(CValidationState &state, const CChainParams&
     CBlockIndex *pindexNewTip = nullptr;
     int nStopAtHeight = gArgs.GetArg("-stopatheight", DEFAULT_STOPATHEIGHT);
     do {
-        boost::this_thread::interruption_point();
-
         // Block until the validation queue drains. This should largely
         // never happen in normal operation, however may happen during
         // reindex, causing memory blowup if we run too far ahead.
@@ -5612,7 +5610,6 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
     int reportDone = 0;
     LogPrintf("[0%%]..."); /* Continued */
     for (pindex = ::ChainActive().Tip(); pindex && pindex->pprev; pindex = pindex->pprev) {
-        boost::this_thread::interruption_point();
         const int percentageDone = std::max(1, std::min(99, (int)(((double)(::ChainActive().Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
         if (reportDone < percentageDone/10) {
             // report every 10% step
@@ -5673,7 +5670,6 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
     // check level 4: try reconnecting blocks
     if (nCheckLevel >= 4) {
         while (pindex != ::ChainActive().Tip()) {
-            boost::this_thread::interruption_point();
             const int percentageDone = std::max(1, std::min(99, 100 - (int)(((double)(::ChainActive().Height() - pindex->nHeight)) / (double)nCheckDepth * 50)));
             if (reportDone < percentageDone/10) {
                 // report every 10% step
@@ -5688,6 +5684,7 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
             std::vector<uint256> dummyRewardedAnchors;
             if (!::ChainstateActive().ConnectBlock(block, state, pindex, coins, mnview, chainparams, dummyRewardedAnchors))
                 return error("VerifyDB(): *** found unconnectable block at %d, hash=%s (%s)", pindex->nHeight, pindex->GetBlockHash().ToString(), FormatStateMessage(state));
+            if (ShutdownRequested()) return true;
         }
     }
 
@@ -6027,7 +6024,7 @@ bool LoadGenesisBlock(const CChainParams& chainparams)
     return ::ChainstateActive().LoadGenesisBlock(chainparams);
 }
 
-bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, FlatFilePos *dbp)
+void LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, FlatFilePos *dbp)
 {
     // Map of disk positions for blocks with unknown parent (only used for reindex)
     static std::multimap<uint256, FlatFilePos> mapBlocksUnknownParent;
@@ -6039,7 +6036,7 @@ bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, FlatFi
         CBufferedFile blkdat(fileIn, 2*MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE+8, SER_DISK, CLIENT_VERSION);
         uint64_t nRewind = blkdat.GetPos();
         while (!blkdat.eof()) {
-            boost::this_thread::interruption_point();
+            if (ShutdownRequested()) return;
 
             blkdat.SetPos(nRewind);
             nRewind++; // start one byte further next time, in case of failure
@@ -6144,9 +6141,7 @@ bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, FlatFi
     } catch (const std::runtime_error& e) {
         AbortNode(std::string("System error: ") + e.what());
     }
-    if (nLoaded > 0)
-        LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, GetTimeMillis() - nStart);
-    return nLoaded > 0;
+    LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, GetTimeMillis() - nStart);
 }
 
 void CChainState::CheckBlockIndex(const Consensus::Params& consensusParams)
diff --git a/src/validation.h b/src/validation.h
index 08eb484878..ecd521677a 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -82,8 +82,8 @@ static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x2000000; // 32 MiB
 /** The pre-allocation chunk size for rev?????.dat files (since 0.8) */
 static const unsigned int UNDOFILE_CHUNK_SIZE = 0x200000; // 2 MiB
 
-/** Maximum number of script-checking threads allowed */
-static const int MAX_SCRIPTCHECK_THREADS = 16;
+/** Maximum number of dedicated script-checking threads allowed */
+static const int MAX_SCRIPTCHECK_THREADS = 15;
 /** -par default (number of script-checking threads, 0 = auto) */
 static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
 /** Number of blocks that can be requested at any given time from a single peer. */
@@ -152,9 +152,12 @@ typedef std::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;
 extern Mutex g_best_block_mutex;
 extern std::condition_variable g_best_block_cv;
 extern uint256 g_best_block;
+/** Whether there are dedicated script-checking threads running.
+ * False indicates all script checking is done on the main threadMessageHandler thread.
+ */
+extern bool g_parallel_script_checks;
 extern std::atomic_bool fImporting;
 extern std::atomic_bool fReindex;
-extern int nScriptCheckThreads;
 extern bool fRequireStandard;
 extern bool fCheckBlockIndex;
 extern bool fCheckpointsEnabled;
@@ -250,7 +253,7 @@ FILE* OpenBlockFile(const FlatFilePos &pos, bool fReadOnly = false);
 /** Translation to a filesystem path */
 fs::path GetBlockPosFilename(const FlatFilePos &pos);
 /** Import blocks from an external file */
-bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, FlatFilePos *dbp = nullptr);
+void LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, FlatFilePos *dbp = nullptr);
 /** Ensures we have a genesis block in the block tree, possibly writing one to disk. */
 bool LoadGenesisBlock(const CChainParams& chainparams);
 /** Load the block tree and coins database from disk,
@@ -260,8 +263,10 @@ bool LoadBlockIndex(const CChainParams& chainparams) EXCLUSIVE_LOCKS_REQUIRED(cs
 bool LoadChainTip(const CChainParams& chainparams) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 /** Unload database information */
 void UnloadBlockIndex();
-/** Run an instance of the script checking thread */
-void ThreadScriptCheck(int worker_num);
+/** Run instances of script checking worker threads */
+void StartScriptCheckWorkerThreads(int threads_num);
+/** Stop all of the script checking worker threads */
+void StopScriptCheckWorkerThreads();
 /** Retrieve a transaction (from memory pool, or from disk, if possible) */
 bool GetTransaction(const uint256& hash, CTransactionRef& tx, const Consensus::Params& params, uint256& hashBlock, const CBlockIndex* const blockIndex = nullptr);
 /**
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index 97b44a70c9..b9dbdace54 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -10,8 +10,6 @@
 #include <primitives/transaction.h>
 #include <wallet/wallet.h>
 
-#include <boost/optional.hpp>
-
 const int DEFAULT_MIN_DEPTH = 0;
 const int DEFAULT_MAX_DEPTH = 9999999;
 
@@ -22,7 +20,7 @@ class CCoinControl
     //! Custom change destination, if not set an address is generated
     CTxDestination destChange;
     //! Override the default change type if set, ignored if destChange is set
-    boost::optional<OutputType> m_change_type;
+    std::optional<OutputType> m_change_type;
     //! If false, allows unselected inputs, but requires all selected inputs be used
     bool fAllowOtherInputs;
     //! Includes watch only addresses which are solvable
@@ -30,11 +28,11 @@ class CCoinControl
     //! Override automatic min/max checks on fee, m_feerate must be set if true
     bool fOverrideFeeRate;
     //! Override the wallet's m_pay_tx_fee if set
-    boost::optional<CFeeRate> m_feerate;
+    std::optional<CFeeRate> m_feerate;
     //! Override the default confirmation target if set
-    boost::optional<unsigned int> m_confirm_target;
+    std::optional<unsigned int> m_confirm_target;
     //! Override the wallet's m_signal_rbf if set
-    boost::optional<bool> m_signal_bip125_rbf;
+    std::optional<bool> m_signal_bip125_rbf;
     //! Avoid partial use of funds sent to a given address
     bool m_avoid_partial_spends;
     //! Forbids inclusion of dirty (previously used) addresses
diff --git a/src/wallet/coinselection.cpp b/src/wallet/coinselection.cpp
index 7644283e2c..33e0bca4f3 100644
--- a/src/wallet/coinselection.cpp
+++ b/src/wallet/coinselection.cpp
@@ -7,8 +7,6 @@
 #include <util/system.h>
 #include <util/moneystr.h>
 
-#include <boost/optional.hpp>
-
 // Descending order comparator
 struct {
     bool operator()(const OutputGroup& a, const OutputGroup& b) const
@@ -219,7 +217,7 @@ bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& group
     nValueRet = 0;
 
     // List of values less than target
-    boost::optional<OutputGroup> lowest_larger;
+    std::optional<OutputGroup> lowest_larger;
     std::vector<OutputGroup> applicable_groups;
     CAmount nTotalLower = 0;
 
diff --git a/src/wallet/db.cpp b/src/wallet/db.cpp
index 827c8a6842..1884a1bdcf 100644
--- a/src/wallet/db.cpp
+++ b/src/wallet/db.cpp
@@ -14,8 +14,6 @@
 #include <sys/stat.h>
 #endif
 
-#include <boost/thread.hpp>
-
 namespace {
 
 //! Make sure database has a unique fileid within the environment. If it
@@ -169,8 +167,6 @@ bool BerkeleyEnvironment::Open(bool retry)
     if (fDbEnvInit)
         return true;
 
-    boost::this_thread::interruption_point();
-
     fs::path pathIn = strPath;
     TryCreateDirectories(pathIn);
     if (!LockDirectory(pathIn, ".walletlock")) {
@@ -243,8 +239,6 @@ BerkeleyEnvironment::BerkeleyEnvironment()
 {
     Reset();
 
-    boost::this_thread::interruption_point();
-
     LogPrint(BCLog::DB, "BerkeleyEnvironment::MakeMock\n");
 
     dbenv->set_cachesize(1, 0, 1);
@@ -360,7 +354,7 @@ bool BerkeleyBatch::Recover(const fs::path& file_path, void *callbackDataIn, boo
     }
     LogPrintf("Salvage(aggressive) found %u records\n", salvagedData.size());
 
-    std::unique_ptr<Db> pdbCopy = MakeUnique<Db>(env->dbenv.get(), 0);
+    std::unique_ptr<Db> pdbCopy = std::make_unique<Db>(env->dbenv.get(), 0);
     int ret = pdbCopy->open(nullptr,               // Txn pointer
                             filename.c_str(),   // Filename
                             "main",             // Logical db name
@@ -538,7 +532,7 @@ BerkeleyBatch::BerkeleyBatch(BerkeleyDatabase& database, const char* pszMode, bo
         pdb = database.m_db.get();
         if (pdb == nullptr) {
             int ret;
-            std::unique_ptr<Db> pdb_temp = MakeUnique<Db>(env->dbenv.get(), 0);
+            std::unique_ptr<Db> pdb_temp = std::make_unique<Db>(env->dbenv.get(), 0);
 
             bool fMockDb = env->IsMock();
             if (fMockDb) {
@@ -696,7 +690,7 @@ bool BerkeleyBatch::Rewrite(BerkeleyDatabase& database, const char* pszSkip)
                 std::string strFileRes = strFile + ".rewrite";
                 { // surround usage of db with extra {}
                     BerkeleyBatch db(database, "r");
-                    std::unique_ptr<Db> pdbCopy = MakeUnique<Db>(env->dbenv.get(), 0);
+                    std::unique_ptr<Db> pdbCopy = std::make_unique<Db>(env->dbenv.get(), 0);
 
                     int ret = pdbCopy->open(nullptr,               // Txn pointer
                                             strFileRes.c_str(), // Filename
@@ -759,7 +753,7 @@ bool BerkeleyBatch::Rewrite(BerkeleyDatabase& database, const char* pszSkip)
                 return fSuccess;
             }
         }
-        MilliSleep(100);
+        UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
@@ -827,7 +821,6 @@ bool BerkeleyBatch::PeriodicFlush(BerkeleyDatabase& database)
 
         if (nRefCount == 0)
         {
-            boost::this_thread::interruption_point();
             std::map<std::string, int>::iterator mi = env->mapFileUseCount.find(strFile);
             if (mi != env->mapFileUseCount.end())
             {
@@ -891,7 +884,7 @@ bool BerkeleyDatabase::Backup(const std::string& strDest)
                 }
             }
         }
-        MilliSleep(100);
+        UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
diff --git a/src/wallet/db.h b/src/wallet/db.h
index 446b508f98..35584d0113 100644
--- a/src/wallet/db.h
+++ b/src/wallet/db.h
@@ -138,19 +138,19 @@ class BerkeleyDatabase
     static std::unique_ptr<BerkeleyDatabase> Create(const fs::path& path)
     {
         std::string filename;
-        return MakeUnique<BerkeleyDatabase>(GetWalletEnv(path, filename), std::move(filename));
+        return std::make_unique<BerkeleyDatabase>(GetWalletEnv(path, filename), std::move(filename));
     }
 
     /** Return object for accessing dummy database with no read/write capabilities. */
     static std::unique_ptr<BerkeleyDatabase> CreateDummy()
     {
-        return MakeUnique<BerkeleyDatabase>();
+        return std::make_unique<BerkeleyDatabase>();
     }
 
     /** Return object for accessing temporary in-memory database. */
     static std::unique_ptr<BerkeleyDatabase> CreateMock()
     {
-        return MakeUnique<BerkeleyDatabase>(std::make_shared<BerkeleyEnvironment>(), "");
+        return std::make_unique<BerkeleyDatabase>(std::make_shared<BerkeleyEnvironment>(), "");
     }
 
     /** Rewrite the entire database on disk, with the exception of key pszSkip if non-zero
diff --git a/src/wallet/feebumper.cpp b/src/wallet/feebumper.cpp
index 78ec00cb91..b048443931 100644
--- a/src/wallet/feebumper.cpp
+++ b/src/wallet/feebumper.cpp
@@ -186,7 +186,7 @@ Result CreateTotalBumpTransaction(const CWallet* wallet, const uint256& txid, co
     }
 
     // Mark new tx not replaceable, if requested.
-    if (!coin_control.m_signal_bip125_rbf.get_value_or(wallet->m_signal_rbf)) {
+    if (!coin_control.m_signal_bip125_rbf.value_or(wallet->m_signal_rbf)) {
         for (auto& input : mtx.vin) {
             if (input.nSequence < 0xfffffffe) input.nSequence = 0xfffffffe;
         }
@@ -285,7 +285,7 @@ Result CreateRateBumpTransaction(CWallet* wallet, const uint256& txid, const CCo
     // Write back transaction
     mtx = CMutableTransaction(*tx_new);
     // Mark new tx not replaceable, if requested.
-    if (!coin_control.m_signal_bip125_rbf.get_value_or(wallet->m_signal_rbf)) {
+    if (!coin_control.m_signal_bip125_rbf.value_or(wallet->m_signal_rbf)) {
         for (auto& input : mtx.vin) {
             if (input.nSequence < 0xfffffffe) input.nSequence = 0xfffffffe;
         }
diff --git a/src/wallet/fees.cpp b/src/wallet/fees.cpp
index 4f1d9da8c9..5e0f74e681 100644
--- a/src/wallet/fees.cpp
+++ b/src/wallet/fees.cpp
@@ -50,7 +50,7 @@ CFeeRate GetMinimumFeeRate(const CWallet& wallet, const CCoinControl& coin_contr
         // We will use smart fee estimation
         unsigned int target = coin_control.m_confirm_target ? *coin_control.m_confirm_target : wallet.m_confirm_target;
         // By default estimates are economical iff we are signaling opt-in-RBF
-        bool conservative_estimate = !coin_control.m_signal_bip125_rbf.get_value_or(wallet.m_signal_rbf);
+        bool conservative_estimate = !coin_control.m_signal_bip125_rbf.value_or(wallet.m_signal_rbf);
         // Allow to override the default fee estimate mode over the CoinControl instance
         if (coin_control.m_fee_mode == FeeEstimateMode::CONSERVATIVE) conservative_estimate = true;
         else if (coin_control.m_fee_mode == FeeEstimateMode::ECONOMICAL) conservative_estimate = false;
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 9909d1bf20..f2c2bd7e4c 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -141,7 +141,7 @@ class WalletClientImpl : public ChainClient
 
 std::unique_ptr<ChainClient> MakeWalletClient(Chain& chain, std::vector<std::string> wallet_filenames)
 {
-    return MakeUnique<WalletClientImpl>(chain, std::move(wallet_filenames));
+    return std::make_unique<WalletClientImpl>(chain, std::move(wallet_filenames));
 }
 
 } // namespace interfaces
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index b73bddf5e1..a44acabb08 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -373,7 +373,7 @@ UniValue importprunedfunds(const JSONRPCRequest& request)
 
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) == merkleBlock.header.hashMerkleRoot) {
 
-        if (locked_chain->getBlockHeight(merkleBlock.header.GetHash()) == nullopt) {
+        if (locked_chain->getBlockHeight(merkleBlock.header.GetHash()) == std::nullopt) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain");
         }
 
@@ -578,7 +578,7 @@ UniValue importwallet(const JSONRPCRequest& request)
         if (!file.is_open()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot open wallet dump file");
         }
-        Optional<int> tip_height = locked_chain->getHeight();
+        std::optional<int> tip_height = locked_chain->getHeight();
         nTimeBegin = tip_height ? locked_chain->getBlockTime(*tip_height) : 0;
 
         int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
@@ -813,8 +813,8 @@ UniValue dumpwallet(const JSONRPCRequest& request)
     // produce output
     file << strprintf("# Wallet dump created by Defi %s\n", CLIENT_BUILD);
     file << strprintf("# * Created on %s\n", FormatISO8601DateTime(GetTime()));
-    const Optional<int> tip_height = locked_chain->getHeight();
-    file << strprintf("# * Best block at time of backup was %i (%s),\n", tip_height.get_value_or(-1), tip_height ? locked_chain->getBlockHash(*tip_height).ToString() : "(missing block hash)");
+    const std::optional<int> tip_height = locked_chain->getHeight();
+    file << strprintf("# * Best block at time of backup was %i (%s),\n", tip_height.value_or(-1), tip_height ? locked_chain->getBlockHash(*tip_height).ToString() : "(missing block hash)");
     file << strprintf("#   mined on %s\n", tip_height ? FormatISO8601DateTime(locked_chain->getBlockTime(*tip_height)) : "(missing block time)");
     file << "\n";
 
@@ -1016,14 +1016,14 @@ static UniValue ProcessImportLegacy(ImportData& import_data, std::map<CKeyID, CP
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid redeem script \"" + strRedeemScript + "\": must be hex string");
         }
         auto parsed_redeemscript = ParseHex(strRedeemScript);
-        import_data.redeemscript = MakeUnique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
+        import_data.redeemscript = std::make_unique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
     }
     if (witness_script_hex.size()) {
         if (!IsHex(witness_script_hex)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid witness script \"" + witness_script_hex + "\": must be hex string");
         }
         auto parsed_witnessscript = ParseHex(witness_script_hex);
-        import_data.witnessscript = MakeUnique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
+        import_data.witnessscript = std::make_unique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
     }
     for (size_t i = 0; i < pubKeys.size(); ++i) {
         const auto& str = pubKeys[i].get_str();
@@ -1386,7 +1386,7 @@ UniValue importmulti(const JSONRPCRequest& mainRequest)
         EnsureWalletIsUnlocked(pwallet);
 
         // Verify all timestamps are present before importing any keys.
-        const Optional<int> tip_height = locked_chain->getHeight();
+        const std::optional<int> tip_height = locked_chain->getHeight();
         now = tip_height ? locked_chain->getBlockMedianTimePast(*tip_height) : 0;
         for (const UniValue& data : requests.getValues()) {
             GetImportTimestamp(data, now);
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index f3ab0f91cd..2d52b13108 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -40,6 +40,7 @@
 #include <univalue.h>
 
 #include <functional>
+
 #include <masternodes/mn_checks.h>
 
 static const std::string WALLET_ENDPOINT_BASE = "/wallet/";
@@ -565,7 +566,7 @@ static UniValue signmessage(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const PKHash *pkhash = boost::get<PKHash>(&dest);
+    const PKHash *pkhash = std::get_if<PKHash>(&dest);
     if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
@@ -1589,9 +1590,8 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
     auto locked_chain = pwallet->chain().lock();
     LOCK2(pwallet->cs_wallet, locked_chain->mutex());
 
-    // The way the 'height' is initialized is just a workaround for the gcc bug #47679 since version 4.6.0.
-    Optional<int> height = MakeOptional(false, int()); // Height of the specified block or the common ancestor, if the block provided was in a deactivated chain.
-    Optional<int> altheight; // Height of the specified block, even if it's in a deactivated chain.
+    std::optional<int> height;    // Height of the specified block or the common ancestor, if the block provided was in a deactivated chain.
+    std::optional<int> altheight; // Height of the specified block, even if it's in a deactivated chain.
     int target_confirms = 1;
     isminefilter filter = ISMINE_SPENDABLE;
 
@@ -1618,7 +1618,7 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
 
     bool include_removed = (request.params[3].isNull() || request.params[3].get_bool());
 
-    const Optional<int> tip_height = locked_chain->getHeight();
+    const std::optional<int> tip_height = locked_chain->getHeight();
     int depth = tip_height && height ? (1 + *tip_height - *height) : -1;
 
     UniValue transactions(UniValue::VARR);
@@ -2616,10 +2616,10 @@ static UniValue loadwallet(const JSONRPCRequest& request)
         for (const auto& entry : wallet->mapAddressBook) {
             if (entry.second.purpose == "spv") {
                 uint160 userHash;
-                if (entry.first.which() == PKHashType) {
-                    userHash = *boost::get<PKHash>(&entry.first);
-                } else if (entry.first.which() == WitV0KeyHashType) {
-                    userHash = *boost::get<WitnessV0KeyHash>(&entry.first);
+                if (entry.first.index() == PKHashType) {
+                    userHash = std::get<PKHash>(entry.first);
+                } else if (entry.first.index() == WitV0KeyHashType) {
+                    userHash = std::get<WitnessV0KeyHash>(entry.first);
                 } else {
                     continue;
                 }
@@ -3001,7 +3001,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
             }
 
             if (scriptPubKey.IsPayToScriptHash()) {
-                const CScriptID& hash = CScriptID(boost::get<ScriptHash>(address));
+                const CScriptID& hash = CScriptID(std::get<ScriptHash>(address));
                 CScript redeemScript;
                 if (pwallet->GetCScript(hash, redeemScript)) {
                     entry.pushKV("redeemScript", HexStr(redeemScript.begin(), redeemScript.end()));
@@ -3011,7 +3011,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
                         bool extracted = ExtractDestination(redeemScript, witness_destination);
                         assert(extracted);
                         // Also return the witness script
-                        const WitnessV0ScriptHash& whash = boost::get<WitnessV0ScriptHash>(witness_destination);
+                        const WitnessV0ScriptHash& whash = std::get<WitnessV0ScriptHash>(witness_destination);
                         CScriptID id;
                         CRIPEMD160().Write(whash.begin(), whash.size()).Finalize(id.begin());
                         CScript witnessScript;
@@ -3021,7 +3021,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
                     }
                 }
             } else if (scriptPubKey.IsPayToWitnessScriptHash()) {
-                const WitnessV0ScriptHash& whash = boost::get<WitnessV0ScriptHash>(address);
+                const WitnessV0ScriptHash& whash = std::get<WitnessV0ScriptHash>(address);
                 CScriptID id;
                 CRIPEMD160().Write(whash.begin(), whash.size()).Finalize(id.begin());
                 CScript witnessScript;
@@ -3547,7 +3547,7 @@ UniValue rescanblockchain(const JSONRPCRequest& request)
     {
         auto locked_chain = pwallet->chain().lock();
         LOCK(locked_chain->mutex());
-        Optional<int> tip_height = locked_chain->getHeight();
+        std::optional<int> tip_height = locked_chain->getHeight();
 
         if (!request.params[0].isNull()) {
             start_height = request.params[0].get_int();
@@ -3556,7 +3556,7 @@ UniValue rescanblockchain(const JSONRPCRequest& request)
             }
         }
 
-        Optional<int> stop_height;
+        std::optional<int> stop_height;
         if (!request.params[1].isNull()) {
             stop_height = request.params[1].get_int();
             if (*stop_height < 0 || !tip_height || *stop_height > *tip_height) {
@@ -3602,7 +3602,7 @@ UniValue rescanblockchain(const JSONRPCRequest& request)
     return response;
 }
 
-class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
+class DescribeWalletAddressVisitor
 {
 public:
     CWallet * const pwallet;
@@ -3621,7 +3621,7 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
             UniValue subobj(UniValue::VOBJ);
             UniValue detail = DescribeAddress(embedded);
             subobj.pushKVs(detail);
-            UniValue wallet_detail = boost::apply_visitor(*this, embedded);
+            UniValue wallet_detail = std::visit(*this, embedded);
             subobj.pushKVs(wallet_detail);
             subobj.pushKV("address", EncodeDestination(embedded));
             subobj.pushKV("scriptPubKey", HexStr(subscript.begin(), subscript.end()));
@@ -3699,7 +3699,7 @@ static UniValue DescribeWalletAddress(CWallet* pwallet, const CTxDestination& de
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     ret.pushKVs(detail);
-    ret.pushKVs(boost::apply_visitor(DescribeWalletAddressVisitor(pwallet), dest));
+    ret.pushKVs(std::visit(DescribeWalletAddressVisitor(pwallet), dest));
     return ret;
 }
 
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index 8689deb03f..45cf5d15b4 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -66,7 +66,7 @@ static void add_coin(const CAmount& nValue, int nAge = 6*24, bool fIsFromMe = fa
         // so stop vin being empty, and cache a non-zero Debit to fake out IsFromMe()
         tx.vin.resize(1);
     }
-    std::unique_ptr<CWalletTx> wtx = MakeUnique<CWalletTx>(&testWallet, MakeTransactionRef(std::move(tx)));
+    std::unique_ptr<CWalletTx> wtx = std::make_unique<CWalletTx>(&testWallet, MakeTransactionRef(std::move(tx)));
     if (fIsFromMe)
     {
         wtx->m_amounts[CWalletTx::DEBIT].Set(ISMINE_SPENDABLE, TAmounts{ {DCT_ID{0}, 1} });
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 897cc32a95..3deaf33169 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -366,7 +366,7 @@ class ListCoinsTestingSetup : public TestChain100Setup
     {
         uint256 masternodesID = testMasternodeKeys.begin()->first;
         CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()), masternodesID);
-        wallet = MakeUnique<CWallet>(m_chain.get(), WalletLocation(), WalletDatabase::CreateMock());
+        wallet = std::make_unique<CWallet>(m_chain.get(), WalletLocation(), WalletDatabase::CreateMock());
         bool firstRun;
         wallet->LoadWallet(firstRun);
         AddKey(*wallet, coinbaseKey);
@@ -432,7 +432,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
         list = wallet->ListCoins(*locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
 
     // Check initial balance from one mature coinbase transaction.
@@ -449,7 +449,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
         list = wallet->ListCoins(*locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 
     // Lock both coins. Confirm number of available coins drops to 0.
@@ -481,7 +481,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
         list = wallet->ListCoins(*locked_chain);
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 }
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 74f9bea2b3..6b3c1158c9 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -444,7 +444,7 @@ void CWallet::UpgradeKeyMetadata()
         return;
     }
 
-    std::unique_ptr<WalletBatch> batch = MakeUnique<WalletBatch>(*database);
+    std::unique_ptr<WalletBatch> batch = std::make_unique<WalletBatch>(*database);
     for (auto& meta_pair : mapKeyMetadata) {
         CKeyMetadata& meta = meta_pair.second;
         if (!meta.hd_seed_id.IsNull() && !meta.has_key_origin && meta.hdKeypath != "s") { // If the hdKeypath is "s", that's the seed and it doesn't have a key origin
@@ -2002,8 +2002,8 @@ int64_t CWallet::RescanFromTime(int64_t startTime, const WalletRescanReserver& r
     {
         auto locked_chain = chain().lock();
         LOCK(locked_chain->mutex());
-        const Optional<int> start_height = locked_chain->findFirstBlockWithTimeAndHeight(startTime - TIMESTAMP_WINDOW, 0, &start_block);
-        const Optional<int> tip_height = locked_chain->getHeight();
+        const std::optional<int> start_height = locked_chain->findFirstBlockWithTimeAndHeight(startTime - TIMESTAMP_WINDOW, 0, &start_block);
+        const std::optional<int> tip_height = locked_chain->getHeight();
         WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__, tip_height && start_height ? *tip_height - *start_height + 1 : 0);
     }
 
@@ -2056,14 +2056,13 @@ CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_bloc
 
     fAbortRescan = false;
     uint256 tip_hash;
-    // The way the 'block_height' is initialized is just a workaround for the gcc bug #47679 since version 4.6.0.
-    Optional<int> block_height = MakeOptional(false, int());
+    std::optional<int> block_height;
     double progress_begin;
     double progress_end;
     {
         auto locked_chain = chain().lock();
         LOCK(locked_chain->mutex());
-        if (Optional<int> tip_height = locked_chain->getHeight()) {
+        if (std::optional<int> tip_height = locked_chain->getHeight()) {
             tip_hash = locked_chain->getBlockHash(*tip_height);
         }
         block_height = locked_chain->getBlockHeight(block_hash);
@@ -2108,7 +2107,7 @@ CWallet::ScanResult CWallet::ScanForWalletTransactions(const uint256& start_bloc
         {
             auto locked_chain = chain().lock();
             LOCK(locked_chain->mutex());
-            Optional<int> tip_height = locked_chain->getHeight();
+            std::optional<int> tip_height = locked_chain->getHeight();
             if (!tip_height || *tip_height <= block_height || !locked_chain->getBlockHeight(block_hash)) {
                 // break successfully when rescan has reached the tip, or
                 // previous block is no longer on the chain due to a reorg
@@ -2595,10 +2594,8 @@ void CWallet::AvailableCoins(interfaces::Chain::Lock& locked_chain, std::vector<
                 continue;
             }
 
-            if (coinControl && coinControl->matchDestination.which() != 0) {
-                CTxDestination dest;
-                ExtractDestination(wtx.tx->vout[i].scriptPubKey, dest);
-                if (dest != coinControl->matchDestination) {
+            if (coinControl && coinControl->matchDestination.index() != 0) {
+                if (wtx.tx->vout[i].scriptPubKey != GetScriptForDestination(coinControl->matchDestination)) {
                     continue;
                 }
             }
@@ -2915,7 +2912,7 @@ static bool IsCurrentForAntiFeeSniping(interfaces::Chain& chain, interfaces::Cha
  */
 static uint32_t GetLocktimeForNewTransaction(interfaces::Chain& chain, interfaces::Chain::Lock& locked_chain)
 {
-    uint32_t const height = locked_chain.getHeight().get_value_or(-1);
+    uint32_t const height = locked_chain.getHeight().value_or(-1);
     uint32_t locktime;
     // Discourage fee sniping.
     //
@@ -3021,7 +3018,7 @@ bool CWallet::CreateTransaction(interfaces::Chain::Lock& locked_chain, const std
         return false;
     }
 
-    const auto txVersion = GetTransactionVersion(locked_chain.getHeight().get_value_or(0));
+    const auto txVersion = GetTransactionVersion(locked_chain.getHeight().value_or(0));
     CMutableTransaction txNew(txVersion);
 
     if (!vTokenValues.empty() && txNew.nVersion < CTransaction::TOKENS_MIN_VERSION)
@@ -3050,7 +3047,7 @@ bool CWallet::CreateTransaction(interfaces::Chain::Lock& locked_chain, const std
             tokensreservedest.emplace(tokenId, std::unique_ptr<ReserveDestination>(new ReserveDestination(this)));  // used dynamic here due to strange bug with direct emplacement under mac
             CScript scriptChange;
             // coin control: send change to custom address
-            if (!boost::get<CNoDestination>(&coin_control.destChange)) {
+            if (!std::get_if<CNoDestination>(&coin_control.destChange)) {
                 scriptChange = GetScriptForDestination(coin_control.destChange);
             } else { // no coin control: send change to newly generated address
                 // Reserve a new key pair from key pool
@@ -3111,7 +3108,7 @@ bool CWallet::CreateTransaction(interfaces::Chain::Lock& locked_chain, const std
             CScript scriptChange;
 
             // coin control: send change to custom address
-            if (!boost::get<CNoDestination>(&coin_control.destChange)) {
+            if (!std::get_if<CNoDestination>(&coin_control.destChange)) {
                 scriptChange = GetScriptForDestination(coin_control.destChange);
             } else { // no coin control: send change to newly generated address
                 // Note: We use a new key here to keep it from being obvious which side is the change.
@@ -3365,7 +3362,7 @@ bool CWallet::CreateTransaction(interfaces::Chain::Lock& locked_chain, const std
         // to avoid conflicting with other possible uses of nSequence,
         // and in the spirit of "smallest possible change from prior
         // behavior."
-        const uint32_t nSequence = coin_control.m_signal_bip125_rbf.get_value_or(m_signal_rbf) ? MAX_BIP125_RBF_SEQUENCE : (CTxIn::SEQUENCE_FINAL - 1);
+        const uint32_t nSequence = coin_control.m_signal_bip125_rbf.value_or(m_signal_rbf) ? MAX_BIP125_RBF_SEQUENCE : (CTxIn::SEQUENCE_FINAL - 1);
         for (const auto& coin : selected_coins) {
             txNew.vin.push_back(CTxIn(coin.outpoint, CScript(), nSequence));
         }
@@ -4175,7 +4172,7 @@ void CWallet::GetKeyBirthTimes(interfaces::Chain::Lock& locked_chain, std::map<C
     }
 
     // map in which we'll infer heights of other keys
-    const Optional<int> tip_height = locked_chain.getHeight();
+    const std::optional<int> tip_height = locked_chain.getHeight();
     const int max_height = tip_height && *tip_height > 144 ? *tip_height - 144 : 0; // the tip can be reorganized; use a 144-block safety margin
     std::map<CKeyID, int> mapKeyFirstBlock;
     for (const CKeyID &keyid : GetKeys()) {
@@ -4190,7 +4187,7 @@ void CWallet::GetKeyBirthTimes(interfaces::Chain::Lock& locked_chain, std::map<C
     // find first block that affects those keys, if there are any left
     for (const auto& wtx : mapWallet.get<ByHash>()) {
         // iterate over all wallet transactions...
-        if (Optional<int> height = locked_chain.getBlockHeight(wtx.hashBlock)) {
+        if (std::optional<int> height = locked_chain.getBlockHeight(wtx.hashBlock)) {
             // ... which are already in a block
             for (const CTxOut &txout : wtx.tx->vout) {
                 // iterate over all their outputs
@@ -4271,7 +4268,7 @@ unsigned int CWallet::ComputeTimeSmart(const CWalletTx& wtx) const
 
 bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
 {
-    if (boost::get<CNoDestination>(&dest))
+    if (std::get_if<CNoDestination>(&dest))
         return false;
 
     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
@@ -4287,7 +4284,7 @@ bool CWallet::EraseDestData(const CTxDestination &dest, const std::string &key)
 
 void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
 {
-    if (boost::get<CNoDestination>(&dest))
+    if (std::get_if<CNoDestination>(&dest))
         return;
 
     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
@@ -4402,7 +4399,7 @@ std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(interfaces::Chain& chain,
     if (gArgs.GetBoolArg("-zapwallettxes", false)) {
         chain.initMessage(_("Zapping all transactions from wallet...").translated);
 
-        std::unique_ptr<CWallet> tempWallet = MakeUnique<CWallet>(&chain, location, WalletDatabase::Create(location.GetPath()));
+        std::unique_ptr<CWallet> tempWallet = std::make_unique<CWallet>(&chain, location, WalletDatabase::Create(location.GetPath()));
         DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
         if (nZapWalletRet != DBErrors::LOAD_OK) {
             chain.initError(strprintf(_("Error loading %s: Wallet corrupted").translated, walletFile));
@@ -4644,13 +4641,13 @@ std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(interfaces::Chain& chain,
         WalletBatch batch(*walletInstance->database);
         CBlockLocator locator;
         if (batch.ReadBestBlock(locator)) {
-            if (const Optional<int> fork_height = locked_chain->findLocatorFork(locator)) {
+            if (const std::optional<int> fork_height = locked_chain->findLocatorFork(locator)) {
                 rescan_height = *fork_height;
             }
         }
     }
 
-    const Optional<int> tip_height = locked_chain->getHeight();
+    const std::optional<int> tip_height = locked_chain->getHeight();
     if (tip_height) {
         walletInstance->m_last_block_processed = locked_chain->getBlockHash(*tip_height);
     } else {
@@ -4683,7 +4680,7 @@ std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(interfaces::Chain& chain,
         // No need to read and scan block if block was created before
         // our wallet birthday (as adjusted for block time variability)
         if (walletInstance->nTimeFirstKey) {
-            if (Optional<int> first_block = locked_chain->findFirstBlockWithTimeAndHeight(walletInstance->nTimeFirstKey - TIMESTAMP_WINDOW, rescan_height, nullptr)) {
+            if (std::optional<int> first_block = locked_chain->findFirstBlockWithTimeAndHeight(walletInstance->nTimeFirstKey - TIMESTAMP_WINDOW, rescan_height, nullptr)) {
                 rescan_height = *first_block;
             }
         }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index cc6d46db33..6a18a25747 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -1079,7 +1079,7 @@ class CWallet final : public FillableSigningProvider, private interfaces::Chain:
         //! Unset if no blocks were scanned due to read errors or the chain
         //! being empty.
         uint256 last_scanned_block;
-        Optional<int> last_scanned_height;
+        std::optional<int> last_scanned_height;
 
         //! Height of the most recent block that could not be scanned due to
         //! read errors or pruning. Will be set if status is FAILURE, unset if
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index ee8d5a89fe..eb0b5d2242 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -19,8 +19,6 @@
 #include <atomic>
 #include <string>
 
-#include <boost/thread.hpp>
-
 namespace DBKeys {
 const std::string ACENTRY{"acentry"};
 const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
@@ -502,9 +500,6 @@ DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
         }
         pcursor->close();
     }
-    catch (const boost::thread_interrupted&) {
-        throw;
-    }
     catch (...) {
         result = DBErrors::CORRUPT;
     }
@@ -603,9 +598,6 @@ DBErrors WalletBatch::FindWalletTx(std::vector<uint256>& vTxHash, std::vector<CW
         }
         pcursor->close();
     }
-    catch (const boost::thread_interrupted&) {
-        throw;
-    }
     catch (...) {
         result = DBErrors::CORRUPT;
     }
diff --git a/test/functional/feature_loan_priceupdate.py b/test/functional/feature_loan_priceupdate.py
index fc357f06ff..937cc1d694 100755
--- a/test/functional/feature_loan_priceupdate.py
+++ b/test/functional/feature_loan_priceupdate.py
@@ -169,8 +169,8 @@ def run_test(self):
         fixedPrice = self.nodes[0].getfixedintervalprice("TSLA/USD")
         assert_equal(fixedPrice['activePrice'], Decimal(15.00000000))
         assert_equal(fixedPrice['nextPrice'], Decimal(15.00000000))
-        assert_equal(fixedPrice['activePriceBlock'], 325)
-        assert_equal(fixedPrice['nextPriceBlock'], 331)
+        assert_equal(fixedPrice['activePriceBlock'], 324)
+        assert_equal(fixedPrice['nextPriceBlock'], 330)
 
         oracle2_prices = [
             {"currency": "USD", "tokenAmount": "15@TSLA"},
@@ -287,15 +287,15 @@ def run_test(self):
         assert_equal(fixedPrice['isLive'], False)
         assert_equal(fixedPrice['activePrice'], Decimal('22.50000000'))
         assert_equal(fixedPrice['nextPrice'], Decimal('57.50000000'))
-        assert_equal(fixedPrice['nextPriceBlock'], 349)
-        assert_equal(fixedPrice['activePriceBlock'], 343)
+        assert_equal(fixedPrice['nextPriceBlock'], 348)
+        assert_equal(fixedPrice['activePriceBlock'], 342)
         self.nodes[0].generate(6)
         fixedPrice = self.nodes[0].getfixedintervalprice("TSLA/USD")
         assert_equal(fixedPrice['isLive'], True)
         assert_equal(fixedPrice['activePrice'], Decimal('57.50000000'))
         assert_equal(fixedPrice['nextPrice'], Decimal('57.50000000'))
-        assert_equal(fixedPrice['nextPriceBlock'], 355)
-        assert_equal(fixedPrice['activePriceBlock'], 349)
+        assert_equal(fixedPrice['nextPriceBlock'], 354)
+        assert_equal(fixedPrice['activePriceBlock'], 348)
 
         fixedPriceList = self.nodes[0].listfixedintervalprices()
         assert_equal(len(fixedPriceList), 3)
diff --git a/test/lint/lint-includes.sh b/test/lint/lint-includes.sh
index f7d609af5b..ac1118e741 100755
--- a/test/lint/lint-includes.sh
+++ b/test/lint/lint-includes.sh
@@ -47,12 +47,9 @@ fi
 
 EXPECTED_BOOST_INCLUDES=(
     boost/algorithm/string.hpp
-    boost/algorithm/string/case_conv.hpp
     boost/algorithm/string/classification.hpp
-    boost/algorithm/string/join.hpp
     boost/algorithm/string/replace.hpp
     boost/algorithm/string/split.hpp
-    boost/chrono/chrono.hpp
     boost/date_time/posix_time/posix_time.hpp
     boost/filesystem.hpp
     boost/filesystem/fstream.hpp
@@ -65,23 +62,12 @@ EXPECTED_BOOST_INCLUDES=(
     boost/multi_index/mem_fun.hpp
     boost/multi_index/member.hpp
     boost/multi_index/tag.hpp
-    boost/optional.hpp
     boost/preprocessor/cat.hpp
     boost/preprocessor/stringize.hpp
-    boost/range/adaptor/transformed.hpp
-    boost/scoped_ptr.hpp
-    boost/shared_ptr.hpp
     boost/signals2/connection.hpp
     boost/signals2/last_value.hpp
     boost/signals2/signal.hpp
     boost/test/unit_test.hpp
-    boost/thread.hpp
-    boost/thread/condition_variable.hpp
-    boost/thread/mutex.hpp
-    boost/thread/thread.hpp
-    boost/variant.hpp
-    boost/variant/apply_visitor.hpp
-    boost/variant/static_visitor.hpp
 )
 
 for BOOST_INCLUDE in $(git grep '^#include <boost/' -- "*.cpp" "*.h" | cut -f2 -d: | cut -f2 -d'<' | cut -f1 -d'>' | sort -u); do