diff --git a/assignment-client/src/audio/AudioMixer.cpp b/assignment-client/src/audio/AudioMixer.cpp
index 7b9f08e837..b0a739caba 100644
--- a/assignment-client/src/audio/AudioMixer.cpp
+++ b/assignment-client/src/audio/AudioMixer.cpp
@@ -95,7 +95,8 @@ AudioMixer::AudioMixer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::NodeIgnoreRequest, this, "handleNodeIgnoreRequestPacket");
     packetReceiver.registerListener(PacketType::KillAvatar, this, "handleKillAvatarPacket");
     packetReceiver.registerListener(PacketType::NodeMuteRequest, this, "handleNodeMuteRequestPacket");
-
+    
+    nodeList->addNodeTypeToInterestSet(NodeType::DomainServer);
     connect(nodeList.data(), &NodeList::nodeKilled, this, &AudioMixer::handleNodeKilled);
 }
 
@@ -603,15 +604,18 @@ void AudioMixer::handleNodeKilled(SharedNodePointer killedNode) {
 void AudioMixer::handleNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode) {
     auto nodeList = DependencyManager::get<NodeList>();
     QUuid nodeUUID = QUuid::fromRfc4122(packet->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
+    if (sendingNode->getCanKick()) {
+        auto node = nodeList->nodeWithUUID(nodeUUID);
+        if (node) {
+            // we need to set a flag so we send them the appropriate packet to mute them
+            AudioMixerClientData* nodeData = (AudioMixerClientData*)node->getLinkedData();
+            nodeData->setShouldMuteClient(true);
 
-    auto node = nodeList->nodeWithUUID(nodeUUID);
-    if (node) {
-        // we need to set a flag so we send them the appropriate packet to mute them
-        AudioMixerClientData* nodeData = (AudioMixerClientData*)node->getLinkedData();
-        nodeData->setShouldMuteClient(true);
-        
+        } else {
+            qWarning() << "Node mute packet received for unknown node " << uuidStringWithoutCurlyBraces(nodeUUID);
+        }
     } else {
-        qWarning() << "Node mute packet received for unknown node " << uuidStringWithoutCurlyBraces(nodeUUID);
+        qWarning() << "Node mute packet received from node that cannot mute, ignoring";
     }
 }
 
diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index b58dd0fe0e..70ee41e934 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -498,7 +498,6 @@ void DomainServer::setupNodeListAndAssignments() {
     // NodeList won't be available to the settings manager when it is created, so call registerListener here
     packetReceiver.registerListener(PacketType::DomainSettingsRequest, &_settingsManager, "processSettingsRequestPacket");
     packetReceiver.registerListener(PacketType::NodeKickRequest, &_settingsManager, "processNodeKickRequestPacket");
-    packetReceiver.registerListener(PacketType::NodeMuteRequest, &_settingsManager, "processNodeMuteRequestPacket");
 
     // register the gatekeeper for the packets it needs to receive
     packetReceiver.registerListener(PacketType::DomainConnectRequest, &_gatekeeper, "processConnectRequestPacket");
diff --git a/domain-server/src/DomainServerSettingsManager.cpp b/domain-server/src/DomainServerSettingsManager.cpp
index ff6c4d62c6..a9db2d9b3f 100644
--- a/domain-server/src/DomainServerSettingsManager.cpp
+++ b/domain-server/src/DomainServerSettingsManager.cpp
@@ -634,39 +634,6 @@ bool DomainServerSettingsManager::ensurePermissionsForGroupRanks() {
     return changed;
 }
 
-void DomainServerSettingsManager::processNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
-    if (sendingNode->getCanKick()) {
-        QUuid nodeUUID = QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
-
-        if (!nodeUUID.isNull() && nodeUUID != sendingNode->getUUID()) {
-            // make sure we actually have a node with this UUID
-            auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
-
-            auto matchingNode = limitedNodeList->nodeWithUUID(nodeUUID);
-
-            if (matchingNode) {
-                // send this along to the audio mixer       
-                auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
-                auto audioMixer = limitedNodeList->soloNodeOfType(NodeType::AudioMixer);
-                if (audioMixer) {
-                    auto packet = NLPacket::create(PacketType::NodeMuteRequest, NUM_BYTES_RFC4122_UUID, true);
-                    packet->write(nodeUUID.toRfc4122());
-                    limitedNodeList->sendPacket(std::move(packet), *audioMixer);
-                } else {
-                    qWarning() << "Couldn't find an audio mixer, cannot process node mute request";
-                }
-            } else {
-                qWarning() << "Node mute request received for unknown node. Refusing to process.";
-            }
-        } else {
-            qWarning() << "Node kick request received for invalid node ID or from node being kicked. Refusing to process.";
-        }
-    } else {
-        qWarning() << "Refusing to process a kick packet from node" << uuidStringWithoutCurlyBraces(sendingNode->getUUID())
-        << "that does not have kick permissions.";
-    }
-}
-
 void DomainServerSettingsManager::processNodeKickRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
     // before we do any processing on this packet make sure it comes from a node that is allowed to kick
     if (sendingNode->getCanKick()) {
diff --git a/domain-server/src/DomainServerSettingsManager.h b/domain-server/src/DomainServerSettingsManager.h
index 7f874226bb..c067377ffc 100644
--- a/domain-server/src/DomainServerSettingsManager.h
+++ b/domain-server/src/DomainServerSettingsManager.h
@@ -105,7 +105,6 @@ public slots:
 private slots:
     void processSettingsRequestPacket(QSharedPointer<ReceivedMessage> message);
     void processNodeKickRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
-    void processNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
 
 private:
     QStringList _argumentList;
diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp
index 782eb8da3e..7a778edaad 100644
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@@ -820,15 +820,20 @@ void NodeList::muteNodeBySessionID(const QUuid& nodeID) {
     // cannot mute yourself, or nobody
     if (!nodeID.isNull() && _sessionUUID != nodeID ) {
         if (getThisNodeCanKick()) {
-            // setup the packet
-            auto kickPacket = NLPacket::create(PacketType::NodeMuteRequest, NUM_BYTES_RFC4122_UUID, true);
+            auto audioMixer = soloNodeOfType(NodeType::AudioMixer);
+            if (audioMixer) {
+                // setup the packet
+                auto mutePacket = NLPacket::create(PacketType::NodeMuteRequest, NUM_BYTES_RFC4122_UUID, true);
 
-            // write the node ID to the packet
-            kickPacket->write(nodeID.toRfc4122());
+                // write the node ID to the packet
+                mutePacket->write(nodeID.toRfc4122());
 
-            qDebug() << "Sending packet to mute node" << uuidStringWithoutCurlyBraces(nodeID);
-
-            sendPacket(std::move(kickPacket), _domainHandler.getSockAddr());
+                qDebug() << "Sending packet to mute node" << uuidStringWithoutCurlyBraces(nodeID);
+            
+                sendPacket(std::move(mutePacket), *audioMixer);
+            } else {
+                qWarning() << "Couldn't find audio mixer to send node mute request";
+            }
         } else {
             qWarning() << "You do not have permissions to mute in this domain."
                 << "Request to mute node" << uuidStringWithoutCurlyBraces(nodeID) << "will not be sent";