diff --git a/autotests/settings/wireguardsettingtest.cpp b/autotests/settings/wireguardsettingtest.cpp
index d6574cb..4861842 100644
--- a/autotests/settings/wireguardsettingtest.cpp
+++ b/autotests/settings/wireguardsettingtest.cpp
@@ -1,106 +1,132 @@
 /*
     Copyright 2019 Jan Grulich <jgrulich@redhat.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "wireguardsettingtest.h"
 
 #include "settings/wireguardsetting.h"
 
 #include <libnm/NetworkManager.h>
 
 #include <QTest>
 
 #if !NM_CHECK_VERSION(1, 16, 0)
 #define NM_SETTING_WIREGUARD_FWMARK            "fwmark"
 #define NM_SETTING_WIREGUARD_LISTEN_PORT       "listen-port"
 #define NM_SETTING_WIREGUARD_PRIVATE_KEY       "private-key"
 #define NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS "private-key-flags"
 #define NM_SETTING_WIREGUARD_PEERS             "peers"
 #define NM_SETTING_WIREGUARD_MTU               "mtu"
 #define NM_SETTING_WIREGUARD_PEER_ROUTES       "peer-routes"
 #endif
 
 void WireguardSettingTest::testSetting_data()
 {
     QTest::addColumn<qint32>("fwmark");
     QTest::addColumn<qint32>("listenPort");
     QTest::addColumn<qint32>("mtu");
     QTest::addColumn<bool>("peerRoutes");
-    QTest::addColumn<QVariantMap>("peers");
+    QTest::addColumn<NMVariantMapList>("peers");
     QTest::addColumn<QString>("privateKey");
     QTest::addColumn<quint32>("privateKeyFlags");
 
+    NMVariantMapList peers;
+    QVariantMap map;
+    map.insert("foo", "bar");
+    peers << map;
+
+    QVariantMap map1;
+    map1.insert("foobar", "barfoo");
+    peers << map1;
+
     QTest::newRow("setting1")
             << (qint32) 100                 // fwmark
             << (qint32) 101                 // listenPort
             << (qint32) 102                 // mtu
             << false                        // peerRoutes
-            << QVariantMap {{"foo", "bar"}} // peers
+            << peers                         // peers
             << QString("private-key")       // privateKey
             << (quint32) 2;                 // privateKeyFlags
 }
 
 void WireguardSettingTest::testSetting()
 {
     QFETCH(qint32, fwmark);
     QFETCH(qint32, listenPort);
     QFETCH(qint32, mtu);
     QFETCH(bool, peerRoutes);
-    QFETCH(QVariantMap, peers);
+    QFETCH(NMVariantMapList, peers);
     QFETCH(QString, privateKey);
     QFETCH(quint32, privateKeyFlags);
 
     QVariantMap map;
 
     map.insert(QLatin1String(NM_SETTING_WIREGUARD_FWMARK), fwmark);
     map.insert(QLatin1String(NM_SETTING_WIREGUARD_LISTEN_PORT), listenPort);
     map.insert(QLatin1String(NM_SETTING_WIREGUARD_MTU), mtu);
     map.insert(QLatin1String(NM_SETTING_WIREGUARD_PEER_ROUTES), peerRoutes);
-    map.insert(QLatin1String(NM_SETTING_WIREGUARD_PEERS), peers);
+    map.insert(QLatin1String(NM_SETTING_WIREGUARD_PEERS), QVariant::fromValue(peers));
     map.insert(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY), privateKey);
     map.insert(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS), privateKeyFlags);
 
     NetworkManager::WireguardSetting setting;
     setting.fromMap(map);
 
     QVariantMap map1 = setting.toMap();
 
     // Will fail if set some default values, because they are skipped in toMap() method
     QVariantMap::const_iterator it = map.constBegin();
     while (it != map.constEnd()) {
         if (it.key() != QLatin1String(NM_SETTING_WIREGUARD_PEERS)) {
             QCOMPARE(it.value(), map1.value(it.key()));
         }
         ++it;
     }
 
-    QVariantMap list = map.value(QLatin1String(NM_SETTING_WIREGUARD_PEERS)).toMap();
-    QVariantMap list1 = map1.value(QLatin1String(NM_SETTING_WIREGUARD_PEERS)).toMap();
+    NMVariantMapList list = map.value(QLatin1String(NM_SETTING_WIREGUARD_PEERS)).value<NMVariantMapList>();
+    NMVariantMapList list1 = map1.value(QLatin1String(NM_SETTING_WIREGUARD_PEERS)).value<NMVariantMapList>();
 
     QCOMPARE(list.count(), list1.count());
 
-    QVariantMap::const_iterator it2 = list.constBegin();
-    while (it2 != list.constEnd()) {
-        QCOMPARE(it2.value(), list1.value(it2.key()));
-        ++it2;
+    int comparedMaps = 0;
+    for (int i = 0; i < list.size(); ++i) {
+        QVariantMap varMap = list.at(i);
+        for (int j = 0; j < list1.size(); ++j) {
+            QVariantMap varMap1 = list1.at(j);
+            QVariantMap::const_iterator ite = varMap.constBegin();
+            int comparedvals = 0;
+            while (ite != varMap.constEnd()) {
+                QVariantMap::const_iterator val1 = varMap1.constFind(ite.key());
+                if (val1 != varMap1.constEnd()) {
+                    if (varMap.value(ite.key()) == val1.value()) {
+                        ++comparedvals;
+                    }
+                }
+                ++ite;
+            }
+            if (comparedvals == varMap.size()) {
+                comparedMaps++;
+            }
+        }
     }
+    QCOMPARE(comparedMaps, list.count());
 }
 
 QTEST_MAIN(WireguardSettingTest)
 
diff --git a/src/settings/wireguardsetting.cpp b/src/settings/wireguardsetting.cpp
index 5c9eb46..e1d5686 100644
--- a/src/settings/wireguardsetting.cpp
+++ b/src/settings/wireguardsetting.cpp
@@ -1,242 +1,242 @@
 /*
     Copyright 2019 Jan Grulich <jgrulich@redhat.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "wireguardsetting.h"
 #include "wireguardsetting_p.h"
 
 #include <QDebug>
 
 #if !NM_CHECK_VERSION(1, 16, 0)
 #define NM_SETTING_WIREGUARD_SETTING_NAME "wireguard"
 
 #define NM_SETTING_WIREGUARD_FWMARK            "fwmark"
 #define NM_SETTING_WIREGUARD_LISTEN_PORT       "listen-port"
 #define NM_SETTING_WIREGUARD_PRIVATE_KEY       "private-key"
 #define NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS "private-key-flags"
 #define NM_SETTING_WIREGUARD_PEERS             "peers"
 #define NM_SETTING_WIREGUARD_MTU               "mtu"
 #define NM_SETTING_WIREGUARD_PEER_ROUTES       "peer-routes"
 #endif
 
 NetworkManager::WireguardSettingPrivate::WireguardSettingPrivate()
     : name(NM_SETTING_WIREGUARD_SETTING_NAME)
     , fwmark(0)
     , listenPort(0)
     , mtu(0)
     , peerRoutes(true)
     , privateKeyFlags(NetworkManager::Setting::None)
 { }
 
 NetworkManager::WireguardSetting::WireguardSetting():
     Setting(Setting::Wireguard),
     d_ptr(new WireguardSettingPrivate())
 { }
 
 NetworkManager::WireguardSetting::WireguardSetting(const Ptr &other)
     : Setting(other)
     , d_ptr(new WireguardSettingPrivate())
 {
     setFwmark(other->fwmark());
     setListenPort(other->listenPort());
     setMtu(other->mtu());
     setPeerRoutes(other->peerRoutes());
     setPeers(other->peers());
     setPrivateKey(other->privateKey());
     setPrivateKeyFlags(other->privateKeyFlags());
 }
 
 NetworkManager::WireguardSetting::~WireguardSetting()
 {
     delete d_ptr;
 }
 
 QString NetworkManager::WireguardSetting::name() const
 {
     Q_D(const WireguardSetting);
 
     return d->name;
 }
 
 quint32 NetworkManager::WireguardSetting::fwmark() const
 {
     Q_D(const WireguardSetting);
 
     return d->fwmark;
 }
 
 void NetworkManager::WireguardSetting::setFwmark(quint32 fwmark)
 {
     Q_D(WireguardSetting);
 
     d->fwmark = fwmark;
 }
 
 quint32 NetworkManager::WireguardSetting::listenPort() const
 {
     Q_D(const WireguardSetting);
 
     return d->listenPort;
 }
 
 void NetworkManager::WireguardSetting::setListenPort(quint32 port)
 {
     Q_D(WireguardSetting);
 
     d->listenPort = port;
 }
 
 quint32 NetworkManager::WireguardSetting::mtu() const
 {
     Q_D(const WireguardSetting);
 
     return d->mtu;
 
 }
 
 void NetworkManager::WireguardSetting::setMtu(quint32 mtu)
 {
     Q_D(WireguardSetting);
 
     d->mtu = mtu;
 }
 
 bool NetworkManager::WireguardSetting::peerRoutes() const
 {
     Q_D(const WireguardSetting);
 
     return d->peerRoutes;
 }
 
 void NetworkManager::WireguardSetting::setPeerRoutes(bool peerRoutes)
 {
     Q_D(WireguardSetting);
 
     d->peerRoutes = peerRoutes;
 }
 
-QVariantMap NetworkManager::WireguardSetting::peers() const
+NMVariantMapList NetworkManager::WireguardSetting::peers() const
 {
     Q_D(const WireguardSetting);
 
     return d->peers;
 }
 
-void NetworkManager::WireguardSetting::setPeers(const QVariantMap &peers)
+void NetworkManager::WireguardSetting::setPeers(const NMVariantMapList &peers)
 {
     Q_D(WireguardSetting);
 
     d->peers = peers;
 }
 
 QString NetworkManager::WireguardSetting::privateKey() const
 {
     Q_D(const WireguardSetting);
 
     return d->privateKey;
 }
 
 void NetworkManager::WireguardSetting::setPrivateKey(const QString &key)
 {
     Q_D(WireguardSetting);
 
     d->privateKey = key;
 }
 
 NetworkManager::Setting::SecretFlags NetworkManager::WireguardSetting::privateKeyFlags() const
 {
     Q_D(const WireguardSetting);
 
     return d->privateKeyFlags;
 }
 
 void NetworkManager::WireguardSetting::setPrivateKeyFlags(NetworkManager::Setting::SecretFlags flags)
 {
     Q_D(WireguardSetting);
 
     d->privateKeyFlags = flags;
 }
 
 void NetworkManager::WireguardSetting::fromMap(const QVariantMap &setting)
 {
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_FWMARK))) {
         setFwmark(setting.value(QLatin1String(NM_SETTING_WIREGUARD_FWMARK)).toInt());
     }
 
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_LISTEN_PORT))) {
         setListenPort(setting.value(QLatin1String(NM_SETTING_WIREGUARD_LISTEN_PORT)).toInt());
     }
 
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_MTU))) {
         setMtu(setting.value(QLatin1String(NM_SETTING_WIREGUARD_MTU)).toInt());
     }
 
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_PEER_ROUTES))) {
         setPeerRoutes(setting.value(QLatin1String(NM_SETTING_WIREGUARD_PEER_ROUTES)).toBool());
     }
 
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_PEERS))) {
-        setPeers(setting.value(QLatin1String(NM_SETTING_WIREGUARD_PEERS)).toMap());
+        setPeers(qdbus_cast<NMVariantMapList>(setting.value(QLatin1String(NM_SETTING_WIREGUARD_PEERS))));
     }
 
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY))) {
         setPrivateKey(setting.value(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY)).toString());
     }
 
     if (setting.contains(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS))) {
         setPrivateKeyFlags((SecretFlags)setting.value(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS)).toInt());
     }
 }
 
 QVariantMap NetworkManager::WireguardSetting::toMap() const
 {
     QVariantMap setting;
 
     setting.insert(QLatin1String(NM_SETTING_WIREGUARD_FWMARK), fwmark());
     setting.insert(QLatin1String(NM_SETTING_WIREGUARD_LISTEN_PORT), listenPort());
     setting.insert(QLatin1String(NM_SETTING_WIREGUARD_MTU), mtu());
     setting.insert(QLatin1String(NM_SETTING_WIREGUARD_PEER_ROUTES), peerRoutes());
 
     if (!peers().isEmpty()) {
-        setting.insert(QLatin1String(NM_SETTING_WIREGUARD_PEERS), peers());
+        setting.insert(QLatin1String(NM_SETTING_WIREGUARD_PEERS), QVariant::fromValue(peers()));
     }
 
     if (!privateKey().isEmpty()) {
         setting.insert(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY), privateKey());
         setting.insert(QLatin1String(NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS), (int)privateKeyFlags());
     }
 
     return setting;
 }
 
 QDebug NetworkManager::operator <<(QDebug dbg, const NetworkManager::WireguardSetting &setting)
 {
     dbg.nospace() << "type: " << setting.typeAsString(setting.type()) << '\n';
     dbg.nospace() << "initialized: " << !setting.isNull() << '\n';
 
     dbg.nospace() << NM_SETTING_WIREGUARD_FWMARK << ": " << setting.fwmark() << '\n';
     dbg.nospace() << NM_SETTING_WIREGUARD_LISTEN_PORT << ": " << setting.listenPort() << '\n';
     dbg.nospace() << NM_SETTING_WIREGUARD_MTU << ": " << setting.mtu() << '\n';
     dbg.nospace() << NM_SETTING_WIREGUARD_PEER_ROUTES << ": " << setting.peerRoutes() << '\n';
     dbg.nospace() << NM_SETTING_WIREGUARD_PEERS << ": " << setting.peers() << '\n';
     dbg.nospace() << NM_SETTING_WIREGUARD_PRIVATE_KEY << ": " << setting.privateKey() << '\n';
     dbg.nospace() << NM_SETTING_WIREGUARD_PRIVATE_KEY_FLAGS << ": " << setting.privateKeyFlags() << '\n';
 
     return dbg.maybeSpace();
 }
diff --git a/src/settings/wireguardsetting.h b/src/settings/wireguardsetting.h
index 7df4b09..6567a77 100644
--- a/src/settings/wireguardsetting.h
+++ b/src/settings/wireguardsetting.h
@@ -1,85 +1,85 @@
 /*
     Copyright 2019 Jan Grulich <jgrulich@redhat.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef NETWORKMANAGERQT_WIREGUARD_SETTING_H
 #define NETWORKMANAGERQT_WIREGUARD_SETTING_H
 
 #include <networkmanagerqt/networkmanagerqt_export.h>
 #include "setting.h"
 
 #include <QString>
 
 namespace NetworkManager
 {
 
 class WireguardSettingPrivate;
 
 /**
  * Represents generic setting
  */
 class NETWORKMANAGERQT_EXPORT WireguardSetting : public Setting
 {
 public:
     typedef QSharedPointer<WireguardSetting> Ptr;
     typedef QList<Ptr> List;
     WireguardSetting();
     explicit WireguardSetting(const Ptr &other);
     ~WireguardSetting() override;
 
     QString name() const override;
 
     quint32 fwmark() const;
     void setFwmark(quint32 fwmark);
 
     quint32 listenPort() const;
     void setListenPort(quint32 port);
 
     quint32 mtu() const;
     void setMtu(quint32 mtu);
 
     bool peerRoutes() const;
     void setPeerRoutes(bool peerRoutes);
 
-    QVariantMap peers() const;
-    void setPeers(const QVariantMap &peers);
+    NMVariantMapList peers() const;
+    void setPeers(const NMVariantMapList &peers);
 
     QString privateKey() const;
     void setPrivateKey(const QString &key);
 
     SecretFlags privateKeyFlags() const;
     void setPrivateKeyFlags(SecretFlags flags);
 
     void fromMap(const QVariantMap &setting) override;
 
     QVariantMap toMap() const override;
 
 protected:
     WireguardSettingPrivate *d_ptr;
 
 private:
     Q_DECLARE_PRIVATE(WireguardSetting)
 };
 
 NETWORKMANAGERQT_EXPORT QDebug operator<<(QDebug dbg, const WireguardSetting &setting);
 
 }
 
 #endif // NETWORKMANAGERQT_WIREGUARD_SETTING_H
 
diff --git a/src/settings/wireguardsetting_p.h b/src/settings/wireguardsetting_p.h
index fc7b315..a1574cc 100644
--- a/src/settings/wireguardsetting_p.h
+++ b/src/settings/wireguardsetting_p.h
@@ -1,48 +1,48 @@
 /*
     Copyright 2019 Jan Grulich <jgrulich@redhat.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef NETWORKMANAGERQT_WIREGUARD_SETTING_P_H
 #define NETWORKMANAGERQT_WIREGUARD_SETTING_P_H
 
 #include <QString>
 
 namespace NetworkManager
 {
 
 class WireguardSettingPrivate
 {
 public:
     WireguardSettingPrivate();
 
     QString name;
 
     quint32 fwmark;
     quint32 listenPort;
     quint32 mtu;
     bool peerRoutes;
-    QVariantMap peers;
+    NMVariantMapList peers;
     QString privateKey;
     NetworkManager::Setting::SecretFlags privateKeyFlags;
 };
 
 }
 
 #endif // NETWORKMANAGERQT_WIREGUARD_SETTING_P_H