diff --git a/src/net_packet.c b/src/net_packet.c
index 40cb2bac..2e47df40 100644
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -687,9 +687,7 @@ static bool send_sptps_data_priv(node_t *to, node_t *from, int type, const void
 	bool relay_supported = (relay->options >> 24) >= 4;
 	bool tcponly = (myself->options | relay->options) & OPTION_TCPONLY;
 
-	/* Send it via TCP if it is a handshake packet, TCPOnly is in use, this is a relay packet that the other node cannot understand, or this packet is larger than the MTU.
-	   TODO: When relaying, the original sender does not know the end-to-end PMTU (it only knows the PMTU of the first hop).
-	         This can lead to scenarios where large packets are sent over UDP to relay, but then relay has no choice but fall back to TCP. */
+	/* Send it via TCP if it is a handshake packet, TCPOnly is in use, this is a relay packet that the other node cannot understand, or this packet is larger than the MTU. */
 
 	if(type == SPTPS_HANDSHAKE || tcponly || (!direct && !relay_supported) || (type != PKT_PROBE && (len - SPTPS_DATAGRAM_OVERHEAD) > relay->minmtu)) {
 		char buf[len * 4 / 3 + 5];
@@ -1422,6 +1420,12 @@ skip_harder:
 	n->sock = ls - listen_socket;
 	if(direct && sockaddrcmp(&addr, &n->address))
 		update_node_udp(n, &addr);
+
+	/* If the packet went through a relay, help the sender find the appropriate MTU
+	   through the relay path. */
+
+	if(!direct)
+		send_mtu_info(myself, n, MTU);
 }
 
 void handle_device_data(void *data, int flags) {
diff --git a/src/protocol.c b/src/protocol.c
index 0ba5c0a4..4f7e6697 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -42,7 +42,7 @@ static bool (*request_handlers[])(connection_t *, const char *) = {
 		add_edge_h, del_edge_h,
 		key_changed_h, req_key_h, ans_key_h, tcppacket_h, control_h,
 		NULL, NULL, NULL, /* Not "real" requests (yet) */
-		udp_info_h,
+		udp_info_h, mtu_info_h,
 };
 
 /* Request names */
@@ -53,7 +53,7 @@ static char (*request_name[]) = {
 		"PING", "PONG",
 		"ADD_SUBNET", "DEL_SUBNET",
 		"ADD_EDGE", "DEL_EDGE", "KEY_CHANGED", "REQ_KEY", "ANS_KEY", "PACKET", "CONTROL",
-		"REQ_PUBKEY", "ANS_PUBKEY", "REQ_SPTPS", "UDP_INFO",
+		"REQ_PUBKEY", "ANS_PUBKEY", "REQ_SPTPS", "UDP_INFO", "MTU_INFO",
 };
 
 static splay_tree_t *past_request_tree;
diff --git a/src/protocol.h b/src/protocol.h
index e4978f4e..c6a1485e 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -26,7 +26,7 @@
 /* Protocol version. Different major versions are incompatible. */
 
 #define PROT_MAJOR 17
-#define PROT_MINOR 5 /* Should not exceed 255! */
+#define PROT_MINOR 6 /* Should not exceed 255! */
 
 /* Silly Windows */
 
@@ -49,7 +49,7 @@ typedef enum request_t {
 	CONTROL,
 	REQ_PUBKEY, ANS_PUBKEY,
 	REQ_SPTPS,
-	UDP_INFO,
+	UDP_INFO, MTU_INFO,
 	LAST                                            /* Guardian for the highest request number */
 } request_t;
 
@@ -109,6 +109,7 @@ extern bool send_req_key(struct node_t *);
 extern bool send_ans_key(struct node_t *);
 extern bool send_tcppacket(struct connection_t *, const struct vpn_packet_t *);
 extern bool send_udp_info(struct node_t *, struct node_t *);
+extern bool send_mtu_info(struct node_t *, struct node_t *, int);
 
 /* Request handlers  */
 
@@ -132,5 +133,6 @@ extern bool ans_key_h(struct connection_t *, const char *);
 extern bool tcppacket_h(struct connection_t *, const char *);
 extern bool control_h(struct connection_t *, const char *);
 extern bool udp_info_h(struct connection_t *, const char *);
+extern bool mtu_info_h(struct connection_t *, const char *);
 
 #endif /* __TINC_PROTOCOL_H__ */
diff --git a/src/protocol_key.c b/src/protocol_key.c
index c46c14cf..8a12b568 100644
--- a/src/protocol_key.c
+++ b/src/protocol_key.c
@@ -178,6 +178,7 @@ static bool req_key_ext_h(connection_t *c, const char *request, node_t *from, in
 			from->last_req_key = now.tv_sec;
 			sptps_start(&from->sptps, from, false, true, myself->connection->ecdsa, from->ecdsa, label, sizeof label, send_sptps_data, receive_sptps_record);
 			sptps_receive_data(&from->sptps, buf, len);
+			send_mtu_info(myself, from, MTU);
 			return true;
 		}
 
@@ -194,6 +195,7 @@ static bool req_key_ext_h(connection_t *c, const char *request, node_t *from, in
 				return true;
 			}
 			sptps_receive_data(&from->sptps, buf, len);
+			send_mtu_info(myself, from, MTU);
 			return true;
 		}
 
@@ -415,6 +417,8 @@ bool ans_key_h(connection_t *c, const char *request) {
 			}
 		}
 
+		send_mtu_info(myself, from, MTU);
+
 		return true;
 	}
 
diff --git a/src/protocol_misc.c b/src/protocol_misc.c
index b2bc40ee..5fde8332 100644
--- a/src/protocol_misc.c
+++ b/src/protocol_misc.c
@@ -237,3 +237,92 @@ bool udp_info_h(connection_t *c, const char* request) {
 
 	return send_udp_info(from, to);
 }
+
+/* Transmitting MTU information */
+
+bool send_mtu_info(node_t *from, node_t *to, int mtu) {
+	/* Skip cases where sending MTU info messages doesn't make sense.
+	   This is done here in order to avoid repeating the same logic in multiple callsites. */
+
+	if(to == myself)
+		return true;
+
+	if(!to->status.reachable)
+		return true;
+
+	if(from == myself && to->connection)
+		return true;
+
+	if((to->nexthop->options >> 24) < 6)
+		return true;
+
+	/* We will send the passed-in MTU value, unless we believe ours is better. */
+
+	node_t *via = (from->via == myself) ? from->nexthop : from->via;
+	if(from->minmtu == from->maxmtu && from->via == myself) {
+		/* We have a direct measurement. Override the value entirely.
+		   Note that we only do that if we are sitting as a static relay in the path;
+		   otherwise, we can't guarantee packets will flow through us, and increasing
+		   MTU could therefore end up being too optimistic. */
+		mtu = from->minmtu;
+	} else if(via->minmtu == via->maxmtu) {
+		/* Static relay. Ensure packets will make it through the entire relay path. */
+		mtu = MIN(mtu, via->minmtu);
+	} else if(via->nexthop->minmtu == via->nexthop->maxmtu) {
+		/* Dynamic relay. Ensure packets will make it through the entire relay path. */
+		mtu = MIN(mtu, via->nexthop->minmtu);
+	}
+
+	/* If none of the conditions above match in the steady state, it means we're using TCP,
+	   so the MTU is irrelevant. That said, it is still important to honor the MTU that was passed in,
+	   because other parts of the relay path might be able to use UDP, which means they care about the MTU. */
+
+	return send_request(to->nexthop->connection, "%d %s %s %d", MTU_INFO, from->name, to->name, mtu);
+}
+
+bool mtu_info_h(connection_t *c, const char* request) {
+	char from_name[MAX_STRING_SIZE];
+	char to_name[MAX_STRING_SIZE];
+	int mtu;
+
+	if(sscanf(request, "%*d "MAX_STRING" "MAX_STRING" %d", from_name, to_name, &mtu) != 3) {
+		logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "MTU_INFO", c->name, c->hostname);
+		return false;
+	}
+
+	if(mtu < 512) {
+		logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "MTU_INFO", c->name, c->hostname, "invalid MTU");
+		return false;
+	}
+
+	mtu = MIN(mtu, MTU);
+
+	if(!check_id(from_name) || !check_id(to_name)) {
+		logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "MTU_INFO", c->name, c->hostname, "invalid name");
+		return false;
+	}
+
+	node_t *from = lookup_node(from_name);
+	if(!from) {
+		logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which does not exist in our connection list", "MTU_INFO", c->name, c->hostname, from_name);
+		return true;
+	}
+
+	/* If we don't know the current MTU for that node, use the one we received.
+	   Even if we're about to make our own measurements, the value we got from downstream nodes should be pretty close
+	   so it's a good idea to use it in the mean time. */
+	if(from->mtu != mtu && from->minmtu != from->maxmtu) {
+		logger(DEBUG_TRAFFIC, LOG_INFO, "Using provisional MTU %d for node %s (%s)", mtu, from->name, from->hostname);
+		from->mtu = mtu;
+	}
+
+	node_t *to = lookup_node(to_name);
+	if(!to) {
+		logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) destination %s which does not exist in our connection list", "MTU_INFO", c->name, c->hostname, to_name);
+		return true;
+	}
+
+	/* Continue passing the MTU value (or a better one if we have it) up the chain. */
+
+	return send_mtu_info(from, to, mtu);
+}