diff --git a/src/outputtype.cpp b/src/outputtype.cpp
--- a/src/outputtype.cpp
+++ b/src/outputtype.cpp
@@ -8,6 +8,7 @@
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/sign.h>
+#include <util/vector.h>
 
 #include <cassert>
 
@@ -41,7 +42,8 @@
 
 std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey &key) {
     PKHash keyid(key);
-    return std::vector<CTxDestination>{std::move(keyid)};
+    CTxDestination p2pkh{keyid};
+    return Vector(std::move(p2pkh));
 }
 
 CTxDestination AddAndGetDestinationForScript(FillableSigningProvider &keystore,
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -14,6 +14,7 @@
 #include <util/spanparsing.h>
 #include <util/strencodings.h>
 #include <util/system.h>
+#include <util/vector.h>
 
 #include <memory>
 #include <string>
@@ -591,13 +592,6 @@
     }
 };
 
-/** Construct a vector with one element, which is moved into it. */
-template <typename T> std::vector<T> Singleton(T elem) {
-    std::vector<T> ret;
-    ret.emplace_back(std::move(elem));
-    return ret;
-}
-
 /** A parsed addr(A) descriptor. */
 class AddressDescriptor final : public DescriptorImpl {
     const CTxDestination m_destination;
@@ -609,7 +603,7 @@
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
-        return Singleton(GetScriptForDestination(m_destination));
+        return Vector(GetScriptForDestination(m_destination));
     }
 
 public:
@@ -630,7 +624,7 @@
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
-        return Singleton(m_script);
+        return Vector(m_script);
     }
 
 public:
@@ -645,12 +639,12 @@
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
-        return Singleton(GetScriptForRawPubKey(keys[0]));
+        return Vector(GetScriptForRawPubKey(keys[0]));
     }
 
 public:
     PKDescriptor(std::unique_ptr<PubkeyProvider> prov)
-        : DescriptorImpl(Singleton(std::move(prov)), {}, "pk") {}
+        : DescriptorImpl(Vector(std::move(prov)), {}, "pk") {}
 };
 
 /** A parsed pkh(P) descriptor. */
@@ -661,12 +655,12 @@
                                      FlatSigningProvider &out) const override {
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
-        return Singleton(GetScriptForDestination(PKHash(id)));
+        return Vector(GetScriptForDestination(PKHash(id)));
     }
 
 public:
     PKHDescriptor(std::unique_ptr<PubkeyProvider> prov)
-        : DescriptorImpl(Singleton(std::move(prov)), {}, "pkh") {}
+        : DescriptorImpl(Vector(std::move(prov)), {}, "pkh") {}
 };
 
 /** A parsed combo(P) descriptor. */
@@ -687,7 +681,7 @@
 
 public:
     ComboDescriptor(std::unique_ptr<PubkeyProvider> prov)
-        : DescriptorImpl(Singleton(std::move(prov)), {}, "combo") {}
+        : DescriptorImpl(Vector(std::move(prov)), {}, "combo") {}
 };
 
 /** A parsed multi(...) descriptor. */
@@ -701,7 +695,7 @@
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
                                      const CScript *,
                                      FlatSigningProvider &) const override {
-        return Singleton(GetScriptForMultisig(m_threshold, keys));
+        return Vector(GetScriptForMultisig(m_threshold, keys));
     }
 
 public:
@@ -717,7 +711,7 @@
     std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
                                      const CScript *script,
                                      FlatSigningProvider &) const override {
-        return Singleton(GetScriptForDestination(ScriptHash(*script)));
+        return Vector(GetScriptForDestination(ScriptHash(*script)));
     }
 
 public:
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -13,6 +13,7 @@
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
+#include <util/vector.h>
 
 #include <test/util/setup_common.h>
 
@@ -2193,4 +2194,107 @@
     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
 }
 
+namespace {
+
+struct Tracker {
+    //! Points to the original object (possibly itself) we moved/copied from
+    const Tracker *origin;
+    //! How many copies where involved between the original object and this one
+    //! (moves are not counted)
+    int copies;
+
+    Tracker() noexcept : origin(this), copies(0) {}
+    Tracker(const Tracker &t) noexcept
+        : origin(t.origin), copies(t.copies + 1) {}
+    Tracker(Tracker &&t) noexcept : origin(t.origin), copies(t.copies) {}
+    Tracker &operator=(const Tracker &t) noexcept {
+        origin = t.origin;
+        copies = t.copies + 1;
+        return *this;
+    }
+    Tracker &operator=(Tracker &&t) noexcept {
+        origin = t.origin;
+        copies = t.copies;
+        return *this;
+    }
+};
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(test_tracked_vector) {
+    Tracker t1;
+    Tracker t2;
+    Tracker t3;
+
+    BOOST_CHECK(t1.origin == &t1);
+    BOOST_CHECK(t2.origin == &t2);
+    BOOST_CHECK(t3.origin == &t3);
+
+    auto v1 = Vector(t1);
+    BOOST_CHECK_EQUAL(v1.size(), 1);
+    BOOST_CHECK(v1[0].origin == &t1);
+    BOOST_CHECK_EQUAL(v1[0].copies, 1);
+
+    auto v2 = Vector(std::move(t2));
+    BOOST_CHECK_EQUAL(v2.size(), 1);
+    BOOST_CHECK(v2[0].origin == &t2);
+    BOOST_CHECK_EQUAL(v2[0].copies, 0);
+
+    auto v3 = Vector(t1, std::move(t2));
+    BOOST_CHECK_EQUAL(v3.size(), 2);
+    BOOST_CHECK(v3[0].origin == &t1);
+    BOOST_CHECK(v3[1].origin == &t2);
+    BOOST_CHECK_EQUAL(v3[0].copies, 1);
+    BOOST_CHECK_EQUAL(v3[1].copies, 0);
+
+    auto v4 = Vector(std::move(v3[0]), v3[1], std::move(t3));
+    BOOST_CHECK_EQUAL(v4.size(), 3);
+    BOOST_CHECK(v4[0].origin == &t1);
+    BOOST_CHECK(v4[1].origin == &t2);
+    BOOST_CHECK(v4[2].origin == &t3);
+    BOOST_CHECK_EQUAL(v4[0].copies, 1);
+    BOOST_CHECK_EQUAL(v4[1].copies, 1);
+    BOOST_CHECK_EQUAL(v4[2].copies, 0);
+
+    auto v5 = Cat(v1, v4);
+    BOOST_CHECK_EQUAL(v5.size(), 4);
+    BOOST_CHECK(v5[0].origin == &t1);
+    BOOST_CHECK(v5[1].origin == &t1);
+    BOOST_CHECK(v5[2].origin == &t2);
+    BOOST_CHECK(v5[3].origin == &t3);
+    BOOST_CHECK_EQUAL(v5[0].copies, 2);
+    BOOST_CHECK_EQUAL(v5[1].copies, 2);
+    BOOST_CHECK_EQUAL(v5[2].copies, 2);
+    BOOST_CHECK_EQUAL(v5[3].copies, 1);
+
+    auto v6 = Cat(std::move(v1), v3);
+    BOOST_CHECK_EQUAL(v6.size(), 3);
+    BOOST_CHECK(v6[0].origin == &t1);
+    BOOST_CHECK(v6[1].origin == &t1);
+    BOOST_CHECK(v6[2].origin == &t2);
+    BOOST_CHECK_EQUAL(v6[0].copies, 1);
+    BOOST_CHECK_EQUAL(v6[1].copies, 2);
+    BOOST_CHECK_EQUAL(v6[2].copies, 1);
+
+    auto v7 = Cat(v2, std::move(v4));
+    BOOST_CHECK_EQUAL(v7.size(), 4);
+    BOOST_CHECK(v7[0].origin == &t2);
+    BOOST_CHECK(v7[1].origin == &t1);
+    BOOST_CHECK(v7[2].origin == &t2);
+    BOOST_CHECK(v7[3].origin == &t3);
+    BOOST_CHECK_EQUAL(v7[0].copies, 1);
+    BOOST_CHECK_EQUAL(v7[1].copies, 1);
+    BOOST_CHECK_EQUAL(v7[2].copies, 1);
+    BOOST_CHECK_EQUAL(v7[3].copies, 0);
+
+    auto v8 = Cat(std::move(v2), std::move(v3));
+    BOOST_CHECK_EQUAL(v8.size(), 3);
+    BOOST_CHECK(v8[0].origin == &t2);
+    BOOST_CHECK(v8[1].origin == &t1);
+    BOOST_CHECK(v8[2].origin == &t2);
+    BOOST_CHECK_EQUAL(v8[0].copies, 0);
+    BOOST_CHECK_EQUAL(v8[1].copies, 1);
+    BOOST_CHECK_EQUAL(v8[2].copies, 0);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txdb.cpp b/src/txdb.cpp
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -12,6 +12,7 @@
 #include <ui_interface.h>
 #include <util/system.h>
 #include <util/translation.h>
+#include <util/vector.h>
 
 #include <boost/thread.hpp> // boost::this_thread::interruption_point() (mingw)
 
@@ -104,7 +105,7 @@
     // A vector is used for future extensibility, as we may want to support
     // interrupting after partial writes from multiple independent reorgs.
     batch.Erase(DB_BEST_BLOCK);
-    batch.Write(DB_HEAD_BLOCKS, std::vector<BlockHash>{hashBlock, old_tip});
+    batch.Write(DB_HEAD_BLOCKS, Vector(hashBlock, old_tip));
 
     for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
         if (it->second.flags & CCoinsCacheEntry::DIRTY) {
diff --git a/src/util/vector.h b/src/util/vector.h
new file mode 100644
--- /dev/null
+++ b/src/util/vector.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_VECTOR_H
+#define BITCOIN_UTIL_VECTOR_H
+
+#include <initializer_list>
+#include <type_traits>
+#include <vector>
+
+/** Construct a vector with the specified elements.
+ *
+ * This is preferable over the list initializing constructor of std::vector:
+ * - It automatically infers the element type from its arguments.
+ * - If any arguments are rvalue references, they will be moved into the vector
+ *   (list initialization always copies).
+ */
+template <typename... Args>
+inline std::vector<typename std::common_type<Args...>::type>
+Vector(Args &&... args) {
+    std::vector<typename std::common_type<Args...>::type> ret;
+    ret.reserve(sizeof...(args));
+    // The line below uses the trick from
+    // https://www.experts-exchange.com/articles/32502/None-recursive-variadic-templates-with-std-initializer-list.html
+    (void)std::initializer_list<int>{
+        (ret.emplace_back(std::forward<Args>(args)), 0)...};
+    return ret;
+}
+
+/** Concatenate two vectors, moving elements. */
+template <typename V> inline V Cat(V v1, V &&v2) {
+    v1.reserve(v1.size() + v2.size());
+    for (auto &arg : v2) {
+        v1.push_back(std::move(arg));
+    }
+    return v1;
+}
+
+/** Concatenate two vectors. */
+template <typename V> inline V Cat(V v1, const V &v2) {
+    v1.reserve(v1.size() + v2.size());
+    for (const auto &arg : v2) {
+        v1.push_back(arg);
+    }
+    return v1;
+}
+
+#endif // BITCOIN_UTIL_VECTOR_H