diff --git a/src/rwcollection.h b/src/rwcollection.h
index ca2814200..ad45a1d72 100644
--- a/src/rwcollection.h
+++ b/src/rwcollection.h
@@ -1,90 +1,88 @@
 // Copyright (c) 2018-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_RWCOLLECTION_H
 #define BITCOIN_RWCOLLECTION_H
 
 #include <threadsafety.h>
 
 #include <boost/range/iterator.hpp>
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
 
 #include <iterator>
+#include <shared_mutex>
 #include <type_traits>
 #include <utility>
 
 template <typename T, typename L> class RWCollectionView {
 private:
     L lock;
     T *collection;
 
     template <typename I> struct BracketType {
         using type = decltype(std::declval<T &>()[std::declval<I>()]);
     };
 
 public:
     RWCollectionView(L l, T &c) : lock(std::move(l)), collection(&c) {}
     RWCollectionView(RWCollectionView &&other)
         : lock(std::move(other.lock)), collection(other.collection) {}
 
     RWCollectionView(const RWCollectionView &) = delete;
     const RWCollectionView &operator=(const RWCollectionView) = delete;
 
     T *operator->() { return collection; }
     const T *operator->() const { return collection; }
 
     /**
      * Iterator mechanics.
      */
     using iterator = typename boost::range_iterator<T>::type;
     iterator begin() { return std::begin(*collection); }
     iterator end() { return std::end(*collection); }
     std::reverse_iterator<iterator> rbegin() {
         return std::rbegin(*collection);
     }
     std::reverse_iterator<iterator> rend() { return std::rend(*collection); }
 
     using const_iterator = typename boost::range_iterator<const T>::type;
     const_iterator begin() const { return std::begin(*collection); }
     const_iterator end() const { return std::end(*collection); }
     std::reverse_iterator<const_iterator> rbegin() const {
         return std::rbegin(*collection);
     }
     std::reverse_iterator<const_iterator> rend() const {
         return std::rend(*collection);
     }
 
     /**
      * Forward bracket operator.
      */
     template <typename I> typename BracketType<I>::type operator[](I &&index) {
         return (*collection)[std::forward<I>(index)];
     }
 };
 
 template <typename T> class RWCollection {
 private:
     T collection;
-    mutable boost::shared_mutex rwmutex;
+    mutable std::shared_mutex rwmutex;
 
 public:
     RWCollection() : collection() {}
 
     using ReadView =
-        RWCollectionView<const T, boost::shared_lock<boost::shared_mutex>>;
+        RWCollectionView<const T, std::shared_lock<std::shared_mutex>>;
     ReadView getReadView() const {
-        return ReadView(boost::shared_lock<boost::shared_mutex>(rwmutex),
+        return ReadView(std::shared_lock<std::shared_mutex>(rwmutex),
                         collection);
     }
 
-    using WriteView =
-        RWCollectionView<T, boost::unique_lock<boost::shared_mutex>>;
+    using WriteView = RWCollectionView<T, std::unique_lock<std::shared_mutex>>;
     WriteView getWriteView() {
-        return WriteView(boost::unique_lock<boost::shared_mutex>(rwmutex),
+        return WriteView(std::unique_lock<std::shared_mutex>(rwmutex),
                          collection);
     }
 };
 
 #endif // BITCOIN_RWCOLLECTION_H
diff --git a/test/lint/lint-boost-dependencies.sh b/test/lint/lint-boost-dependencies.sh
index 66c2bd1ea..a404b86db 100755
--- a/test/lint/lint-boost-dependencies.sh
+++ b/test/lint/lint-boost-dependencies.sh
@@ -1,65 +1,64 @@
 #!/usr/bin/env bash
 #
 # Copyright (c) 2018 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 # Guard against accidental introduction of new Boost dependencies.
 
 export LC_ALL=C
 
 EXPECTED_BOOST_INCLUDES=(
     boost/algorithm/string.hpp
     boost/algorithm/string/classification.hpp
     boost/algorithm/string/replace.hpp
     boost/algorithm/string/split.hpp
     boost/date_time/posix_time/posix_time.hpp
     boost/filesystem.hpp
     boost/filesystem/fstream.hpp
     boost/multi_index/composite_key.hpp
     boost/multi_index/hashed_index.hpp
     boost/multi_index/member.hpp
     boost/multi_index/ordered_index.hpp
     boost/multi_index/sequenced_index.hpp
     boost/multi_index_container.hpp
     boost/preprocessor/cat.hpp
     boost/preprocessor/stringize.hpp
     boost/range/iterator.hpp
     boost/range/adaptor/sliced.hpp
     boost/signals2/connection.hpp
     boost/signals2/last_value.hpp
     boost/signals2/signal.hpp
     boost/test/unit_test.hpp
     boost/thread/condition_variable.hpp
-    boost/thread/locks.hpp
     boost/thread/mutex.hpp
     boost/thread/shared_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
     IS_EXPECTED_INCLUDE=0
     for EXPECTED_BOOST_INCLUDE in "${EXPECTED_BOOST_INCLUDES[@]}"; do
         if [[ "${BOOST_INCLUDE}" == "${EXPECTED_BOOST_INCLUDE}" ]]; then
             IS_EXPECTED_INCLUDE=1
             break
         fi
     done
     if [[ ${IS_EXPECTED_INCLUDE} == 0 ]]; then
         echo "A new Boost dependency in the form of \"${BOOST_INCLUDE}\" appears to have been introduced:"
         git grep "${BOOST_INCLUDE}" -- "*.cpp" "*.h"
         echo
     fi
 done
 
 for EXPECTED_BOOST_INCLUDE in "${EXPECTED_BOOST_INCLUDES[@]}"; do
     if ! git grep -q "^#include <${EXPECTED_BOOST_INCLUDE}>" -- "*.cpp" "*.h"; then
         echo "Good job! The Boost dependency \"${EXPECTED_BOOST_INCLUDE}\" is no longer used."
         echo "Please remove it from EXPECTED_BOOST_INCLUDES in $0"
         echo "to make sure this dependency is not accidentally reintroduced."
         echo
     fi
 done