--- a/media/mtransport/test_nr_socket.cpp
+++ b/media/mtransport/test_nr_socket.cpp
@@ -382,17 +382,17 @@ int TestNrSocket::recvfrom(void *buf, si
   if (readable_socket_) {
     // If any of the external sockets got data, see if it will be passed through
     r = readable_socket_->recvfrom(buf, maxlen, len, 0, from);
     readable_socket_ = nullptr;
     if (!r) {
       PortMapping *port_mapping_used;
       ingress_allowed = allow_ingress(*from, &port_mapping_used);
       if (ingress_allowed) {
-        r_log(LOG_GENERIC, LOG_INFO, "TestNrSocket %s received from %s via %s",
+        r_log(LOG_GENERIC, LOG_DEBUG, "TestNrSocket %s received from %s via %s",
               internal_socket_->my_addr().as_string,
               from->as_string,
               port_mapping_used->external_socket_->my_addr().as_string);
         if (nat_->refresh_on_ingress_) {
           port_mapping_used->last_used_ = PR_IntervalNow();
         }
       }
     }
@@ -407,17 +407,17 @@ int TestNrSocket::recvfrom(void *buf, si
       ingress_allowed = (!nat_->enabled_ ||
                          nat_->is_an_internal_tuple(*from));
       if (!ingress_allowed) {
         r_log(LOG_GENERIC, LOG_INFO, "TestNrSocket %s denying ingress from %s: "
               "Not behind the same NAT",
               internal_socket_->my_addr().as_string,
               from->as_string);
       } else {
-        r_log(LOG_GENERIC, LOG_INFO, "TestNrSocket %s received from %s",
+        r_log(LOG_GENERIC, LOG_DEBUG, "TestNrSocket %s received from %s",
               internal_socket_->my_addr().as_string,
               from->as_string);
       }
     }
   }
 
   // Kinda lame that we are forced to give the app a readable callback and then
   // say "Oh, never mind...", but the alternative is to totally decouple the
@@ -507,28 +507,28 @@ int TestNrSocket::connect(nr_transport_a
 
   return r;
 }
 
 int TestNrSocket::write(const void *msg, size_t len, size_t *written) {
 
   if (port_mappings_.empty()) {
     // The no-nat case, just pass call through.
-    r_log(LOG_GENERIC, LOG_INFO, "TestNrSocket %s writing",
+    r_log(LOG_GENERIC, LOG_DEBUG, "TestNrSocket %s writing",
           my_addr().as_string);
 
     return internal_socket_->write(msg, len, written);
   } else {
     destroy_stale_port_mappings();
     if (port_mappings_.empty()) {
       return -1;
     }
     // This is TCP only
     MOZ_ASSERT(port_mappings_.size() == 1);
-    r_log(LOG_GENERIC, LOG_INFO,
+    r_log(LOG_GENERIC, LOG_DEBUG,
           "PortMapping %s -> %s writing",
           port_mappings_.front()->external_socket_->my_addr().as_string,
           port_mappings_.front()->remote_address_.as_string);
 
     port_mappings_.front()->last_used_ = PR_IntervalNow();
     return port_mappings_.front()->external_socket_->write(msg, len, written);
   }
 }
@@ -742,17 +742,17 @@ void TestNrSocket::write_to_port_mapping
                   this);
   }
 }
 
 void TestNrSocket::port_mapping_tcp_passthrough_callback(void *ext_sock_v,
                                                          int how,
                                                          void *test_sock_v) {
   TestNrSocket *test_socket = static_cast<TestNrSocket*>(test_sock_v);
-  r_log(LOG_GENERIC, LOG_INFO,
+  r_log(LOG_GENERIC, LOG_DEBUG,
         "TestNrSocket %s firing %s callback",
         test_socket->internal_socket_->my_addr().as_string,
         how == NR_ASYNC_WAIT_READ ? "readable" : "writeable");
 
 
   test_socket->internal_socket_->fire_callback(how);
 }
 
@@ -808,61 +808,61 @@ TestNrSocket::PortMapping::PortMapping(
 }
 
 int TestNrSocket::PortMapping::send_from_queue() {
   MOZ_ASSERT(remote_address_.protocol != IPPROTO_TCP);
   int r = 0;
 
   while (!send_queue_.empty()) {
     UdpPacket &packet = *send_queue_.front();
-    r_log(LOG_GENERIC, LOG_INFO,
+    r_log(LOG_GENERIC, LOG_DEBUG,
           "PortMapping %s -> %s sending from queue to %s",
           external_socket_->my_addr().as_string,
           remote_address_.as_string,
           packet.remote_address_.as_string);
 
     r = external_socket_->sendto(packet.buffer_->data(),
                                  packet.buffer_->len(),
                                  0,
                                  &packet.remote_address_);
 
     if (r) {
       if (r != R_WOULDBLOCK) {
         r_log(LOG_GENERIC, LOG_ERR, "%s: Fatal error %d, stop trying",
               __FUNCTION__, r);
         send_queue_.clear();
       } else {
-        r_log(LOG_GENERIC, LOG_INFO, "Would block, will retry later");
+        r_log(LOG_GENERIC, LOG_DEBUG, "Would block, will retry later");
       }
       break;
     }
 
     send_queue_.pop_front();
   }
 
   return r;
 }
 
 int TestNrSocket::PortMapping::sendto(const void *msg,
                                       size_t len,
                                       const nr_transport_addr &to) {
   MOZ_ASSERT(remote_address_.protocol != IPPROTO_TCP);
-  r_log(LOG_GENERIC, LOG_INFO,
+  r_log(LOG_GENERIC, LOG_DEBUG,
         "PortMapping %s -> %s sending to %s",
         external_socket_->my_addr().as_string,
         remote_address_.as_string,
         to.as_string);
 
   last_used_ = PR_IntervalNow();
   int r = external_socket_->sendto(msg, len, 0,
       // TODO(bug 1170299): Remove const_cast when no longer necessary
       const_cast<nr_transport_addr*>(&to));
 
   if (r == R_WOULDBLOCK) {
-    r_log(LOG_GENERIC, LOG_INFO, "Enqueueing UDP packet to %s", to.as_string);
+    r_log(LOG_GENERIC, LOG_DEBUG, "Enqueueing UDP packet to %s", to.as_string);
     send_queue_.push_back(RefPtr<UdpPacket>(new UdpPacket(msg, len, to)));
     return 0;
   } else if (r) {
     r_log(LOG_GENERIC,LOG_ERR, "Error: %d", r);
   }
 
   return r;
 }