diff --git a/src/basic/time-util.c b/src/basic/time-util.c
index 1db630003a..a6790d207c 100644
--- a/src/basic/time-util.c
+++ b/src/basic/time-util.c
@@ -156,6 +156,25 @@ triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u)
         return ts;
 }
 
+triple_timestamp* triple_timestamp_from_boottime(triple_timestamp *ts, usec_t u) {
+        usec_t nowb;
+
+        assert(ts);
+
+        if (u == USEC_INFINITY) {
+                ts->realtime = ts->monotonic = ts->boottime = u;
+                return ts;
+        }
+
+        nowb = now(CLOCK_BOOTTIME);
+
+        ts->boottime = u;
+        ts->monotonic = map_clock_usec_internal(u, nowb, now(CLOCK_MONOTONIC));
+        ts->realtime = map_clock_usec_internal(u, nowb, now(CLOCK_REALTIME));
+
+        return ts;
+}
+
 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
         assert(ts);
 
diff --git a/src/basic/time-util.h b/src/basic/time-util.h
index 57283d31a7..b648a3b59e 100644
--- a/src/basic/time-util.h
+++ b/src/basic/time-util.h
@@ -86,6 +86,7 @@ dual_timestamp* dual_timestamp_from_boottime(dual_timestamp *ts, usec_t u);
 
 triple_timestamp* triple_timestamp_get(triple_timestamp *ts);
 triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u);
+triple_timestamp* triple_timestamp_from_boottime(triple_timestamp *ts, usec_t u);
 
 #define DUAL_TIMESTAMP_HAS_CLOCK(clock)                               \
         IN_SET(clock, CLOCK_REALTIME, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC)
diff --git a/src/libsystemd-network/dhcp-lease-internal.h b/src/libsystemd-network/dhcp-lease-internal.h
index 6503e3ce2d..04a9893876 100644
--- a/src/libsystemd-network/dhcp-lease-internal.h
+++ b/src/libsystemd-network/dhcp-lease-internal.h
@@ -10,6 +10,7 @@
 #include "dhcp-internal.h"
 #include "dhcp-protocol.h"
 #include "list.h"
+#include "time-util.h"
 
 struct sd_dhcp_route {
         struct in_addr dst_addr;
@@ -29,9 +30,10 @@ struct sd_dhcp_lease {
         unsigned n_ref;
 
         /* each 0 if unset */
-        uint32_t t1;
-        uint32_t t2;
-        uint32_t lifetime;
+        usec_t t1;
+        usec_t t2;
+        usec_t lifetime;
+        triple_timestamp timestamp;
 
         /* each 0 if unset */
         be32_t address;
diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c
index 9ec7a2256e..854eca5a58 100644
--- a/src/libsystemd-network/sd-dhcp-client.c
+++ b/src/libsystemd-network/sd-dhcp-client.c
@@ -102,7 +102,7 @@ struct sd_dhcp_client {
         char *mudurl;
         char **user_class;
         uint32_t mtu;
-        uint32_t fallback_lease_lifetime;
+        usec_t fallback_lease_lifetime;
         uint32_t xid;
         usec_t start_time;
         usec_t t1_time;
@@ -716,18 +716,6 @@ int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) {
         return 0;
 }
 
-int sd_dhcp_client_get_lease_timestamp(sd_dhcp_client *client, uint64_t *timestamp) {
-        assert_return(client, -EINVAL);
-
-        if (!IN_SET(client->state, DHCP_STATE_BOUND, DHCP_STATE_RENEWING, DHCP_STATE_REBINDING))
-                return -ENODATA;
-
-        if(timestamp)
-                *timestamp = client->request_sent;
-
-        return 0;
-}
-
 int sd_dhcp_client_set_service_type(sd_dhcp_client *client, int type) {
         assert_return(client, -EINVAL);
         assert_return(!sd_dhcp_client_is_running(client), -EBUSY);
@@ -747,11 +735,12 @@ int sd_dhcp_client_set_socket_priority(sd_dhcp_client *client, int socket_priori
         return 0;
 }
 
-int sd_dhcp_client_set_fallback_lease_lifetime(sd_dhcp_client *client, uint32_t fallback_lease_lifetime) {
+int sd_dhcp_client_set_fallback_lease_lifetime(sd_dhcp_client *client, uint64_t fallback_lease_lifetime) {
         assert_return(client, -EINVAL);
         assert_return(!sd_dhcp_client_is_running(client), -EBUSY);
         assert_return(fallback_lease_lifetime > 0, -EINVAL);
 
+        assert_cc(sizeof(usec_t) == sizeof(uint64_t));
         client->fallback_lease_lifetime = fallback_lease_lifetime;
 
         return 0;
@@ -1290,8 +1279,7 @@ static int client_timeout_resend(
 
         sd_dhcp_client *client = ASSERT_PTR(userdata);
         DHCP_CLIENT_DONT_DESTROY(client);
-        usec_t next_timeout;
-        uint64_t time_now;
+        usec_t time_now, next_timeout;
         int r;
 
         assert(s);
@@ -1439,7 +1427,7 @@ error:
 }
 
 static int client_initialize_time_events(sd_dhcp_client *client) {
-        uint64_t usec = 0;
+        usec_t usec = 0;
         int r;
 
         assert(client);
@@ -1447,7 +1435,7 @@ static int client_initialize_time_events(sd_dhcp_client *client) {
 
         if (client->start_delay > 0) {
                 assert_se(sd_event_now(client->event, CLOCK_BOOTTIME, &usec) >= 0);
-                usec += client->start_delay;
+                usec = usec_add(usec, client->start_delay);
         }
 
         r = event_reset_time(client->event, &client->timeout_resend,
@@ -1725,10 +1713,12 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
         assert(client);
         assert(client->event);
         assert(client->lease);
-        assert(client->lease->lifetime);
+        assert(client->lease->lifetime > 0);
+
+        triple_timestamp_from_boottime(&client->lease->timestamp, client->request_sent);
 
         /* don't set timers for infinite leases */
-        if (client->lease->lifetime == 0xffffffff) {
+        if (client->lease->lifetime == USEC_INFINITY) {
                 (void) event_source_disable(client->timeout_t1);
                 (void) event_source_disable(client->timeout_t2);
                 (void) event_source_disable(client->timeout_expire);
@@ -1748,14 +1738,18 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
         if (client->lease->t1 == 0 || client->lease->t1 >= client->lease->t2)
                 client->lease->t1 = T1_DEFAULT(client->lease->lifetime);
         /* now, if t1 >= t2, t1 *must* be T1_DEFAULT, since the previous check
-         * could not evalate to false if t1 >= t2; so setting t2 to T2_DEFAULT
+         * could not evaluate to false if t1 >= t2; so setting t2 to T2_DEFAULT
          * guarantees t1 < t2. */
         if (client->lease->t1 >= client->lease->t2)
                 client->lease->t2 = T2_DEFAULT(client->lease->lifetime);
 
-        client->expire_time = client->request_sent + client->lease->lifetime * USEC_PER_SEC;
-        client->t1_time = client->request_sent + client->lease->t1 * USEC_PER_SEC;
-        client->t2_time = client->request_sent + client->lease->t2 * USEC_PER_SEC;
+        assert(client->lease->t1 > 0);
+        assert(client->lease->t1 < client->lease->t2);
+        assert(client->lease->t2 < client->lease->lifetime);
+
+        client->expire_time = usec_add(client->request_sent, client->lease->lifetime);
+        client->t1_time = usec_add(client->request_sent, client->lease->t1);
+        client->t2_time = usec_add(client->request_sent, client->lease->t2);
 
         /* RFC2131 section 4.4.5:
          * Times T1 and T2 SHOULD be chosen with some random "fuzz".
diff --git a/src/libsystemd-network/sd-dhcp-lease.c b/src/libsystemd-network/sd-dhcp-lease.c
index d09908b5a2..b8be34a9f4 100644
--- a/src/libsystemd-network/sd-dhcp-lease.c
+++ b/src/libsystemd-network/sd-dhcp-lease.c
@@ -29,9 +29,23 @@
 #include "stdio-util.h"
 #include "string-util.h"
 #include "strv.h"
+#include "time-util.h"
 #include "tmpfile-util.h"
 #include "unaligned.h"
 
+int sd_dhcp_lease_get_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret) {
+        assert_return(lease, -EINVAL);
+        assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
+        assert_return(clock_supported(clock), -EOPNOTSUPP);
+        assert_return(ret, -EINVAL);
+
+        if (!triple_timestamp_is_set(&lease->timestamp))
+                return -ENODATA;
+
+        *ret = triple_timestamp_by_clock(&lease->timestamp, clock);
+        return 0;
+}
+
 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
@@ -54,39 +68,66 @@ int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr) {
         return 0;
 }
 
-int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime) {
+int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint64_t *ret) {
         assert_return(lease, -EINVAL);
-        assert_return(lifetime, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (lease->lifetime <= 0)
                 return -ENODATA;
 
-        *lifetime = lease->lifetime;
+        *ret = lease->lifetime;
         return 0;
 }
 
-int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1) {
+int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint64_t *ret) {
         assert_return(lease, -EINVAL);
-        assert_return(t1, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (lease->t1 <= 0)
                 return -ENODATA;
 
-        *t1 = lease->t1;
+        *ret = lease->t1;
         return 0;
 }
 
-int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2) {
+int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint64_t *ret) {
         assert_return(lease, -EINVAL);
-        assert_return(t2, -EINVAL);
+        assert_return(ret, -EINVAL);
 
         if (lease->t2 <= 0)
                 return -ENODATA;
 
-        *t2 = lease->t2;
+        *ret = lease->t2;
         return 0;
 }
 
+#define DEFINE_GET_TIMESTAMP(name)                                      \
+        int sd_dhcp_lease_get_##name##_timestamp(                       \
+                        sd_dhcp_lease *lease,                           \
+                        clockid_t clock,                                \
+                        uint64_t *ret) {                                \
+                                                                        \
+                usec_t t, timestamp;                                    \
+                int r;                                                  \
+                                                                        \
+                assert_return(ret, -EINVAL);                            \
+                                                                        \
+                r = sd_dhcp_lease_get_##name(lease, &t);                \
+                if (r < 0)                                              \
+                        return r;                                       \
+                                                                        \
+                r = sd_dhcp_lease_get_timestamp(lease, clock, &timestamp); \
+                if (r < 0)                                              \
+                        return r;                                       \
+                                                                        \
+                *ret = usec_add(t, timestamp);                          \
+                return 0;                                               \
+        }
+
+DEFINE_GET_TIMESTAMP(lifetime);
+DEFINE_GET_TIMESTAMP(t1);
+DEFINE_GET_TIMESTAMP(t2);
+
 int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
         assert_return(lease, -EINVAL);
         assert_return(mtu, -EINVAL);
@@ -331,6 +372,10 @@ int sd_dhcp_lease_get_6rd(
         return 0;
 }
 
+int sd_dhcp_lease_has_6rd(sd_dhcp_lease *lease) {
+        return lease && lease->sixrd_n_br_addresses > 0;
+}
+
 int sd_dhcp_lease_get_vendor_specific(sd_dhcp_lease *lease, const void **data, size_t *data_len) {
         assert_return(lease, -EINVAL);
         assert_return(data, -EINVAL);
@@ -389,6 +434,25 @@ static int lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uin
         return 0;
 }
 
+static int lease_parse_u32_seconds(const uint8_t *option, size_t len, usec_t *ret) {
+        uint32_t val;
+        int r;
+
+        assert(option);
+        assert(ret);
+
+        r = lease_parse_u32(option, len, &val, 1);
+        if (r < 0)
+                return r;
+
+        if (val == UINT32_MAX)
+                *ret = USEC_INFINITY;
+        else
+                *ret = val * USEC_PER_SEC;
+
+        return 0;
+}
+
 static int lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
         assert(option);
         assert(ret);
@@ -658,7 +722,7 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
         switch (code) {
 
         case SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
-                r = lease_parse_u32(option, len, &lease->lifetime, 1);
+                r = lease_parse_u32_seconds(option, len, &lease->lifetime);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse lease time, ignoring: %m");
 
@@ -783,13 +847,13 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
                 break;
 
         case SD_DHCP_OPTION_RENEWAL_TIME:
-                r = lease_parse_u32(option, len, &lease->t1, 1);
+                r = lease_parse_u32_seconds(option, len, &lease->t1);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse T1 time, ignoring: %m");
                 break;
 
         case SD_DHCP_OPTION_REBINDING_TIME:
-                r = lease_parse_u32(option, len, &lease->t2, 1);
+                r = lease_parse_u32_seconds(option, len, &lease->t2);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse T2 time, ignoring: %m");
                 break;
@@ -1002,7 +1066,7 @@ int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
         uint16_t mtu;
         _cleanup_free_ sd_dhcp_route **routes = NULL;
         char **search_domains;
-        uint32_t t1, t2, lifetime;
+        usec_t t;
         int r;
 
         assert(lease);
@@ -1048,17 +1112,17 @@ int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
         if (r >= 0)
                 fprintf(f, "MTU=%" PRIu16 "\n", mtu);
 
-        r = sd_dhcp_lease_get_t1(lease, &t1);
+        r = sd_dhcp_lease_get_t1(lease, &t);
         if (r >= 0)
-                fprintf(f, "T1=%" PRIu32 "\n", t1);
+                fprintf(f, "T1=%s\n", FORMAT_TIMESPAN(t, USEC_PER_SEC));
 
-        r = sd_dhcp_lease_get_t2(lease, &t2);
+        r = sd_dhcp_lease_get_t2(lease, &t);
         if (r >= 0)
-                fprintf(f, "T2=%" PRIu32 "\n", t2);
+                fprintf(f, "T2=%s\n", FORMAT_TIMESPAN(t, USEC_PER_SEC));
 
-        r = sd_dhcp_lease_get_lifetime(lease, &lifetime);
+        r = sd_dhcp_lease_get_lifetime(lease, &t);
         if (r >= 0)
-                fprintf(f, "LIFETIME=%" PRIu32 "\n", lifetime);
+                fprintf(f, "LIFETIME=%s\n", FORMAT_TIMESPAN(t, USEC_PER_SEC));
 
         r = sd_dhcp_lease_get_dns(lease, &addresses);
         if (r > 0) {
@@ -1390,19 +1454,19 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
         }
 
         if (lifetime) {
-                r = safe_atou32(lifetime, &lease->lifetime);
+                r = parse_sec(lifetime, &lease->lifetime);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse lifetime %s, ignoring: %m", lifetime);
         }
 
         if (t1) {
-                r = safe_atou32(t1, &lease->t1);
+                r = parse_sec(t1, &lease->t1);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse T1 %s, ignoring: %m", t1);
         }
 
         if (t2) {
-                r = safe_atou32(t2, &lease->t2);
+                r = parse_sec(t2, &lease->t2);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse T2 %s, ignoring: %m", t2);
         }
diff --git a/src/network/networkd-dhcp-prefix-delegation.c b/src/network/networkd-dhcp-prefix-delegation.c
index 169f1b3b5e..c6e6857aa4 100644
--- a/src/network/networkd-dhcp-prefix-delegation.c
+++ b/src/network/networkd-dhcp-prefix-delegation.c
@@ -51,13 +51,6 @@ bool dhcp_pd_is_uplink(Link *link, Link *target, bool accept_auto) {
         return accept_auto;
 }
 
-bool dhcp4_lease_has_pd_prefix(sd_dhcp_lease *lease) {
-        if (!lease)
-                return false;
-
-        return sd_dhcp_lease_get_6rd(lease, NULL, NULL, NULL, NULL, NULL) >= 0;
-}
-
 bool dhcp6_lease_has_pd_prefix(sd_dhcp6_lease *lease) {
         uint32_t lifetime_preferred_sec, lifetime_valid_sec;
         struct in6_addr pd_prefix;
@@ -855,8 +848,7 @@ static int dhcp4_pd_assign_subnet_prefix(Link *link, Link *uplink) {
         struct in6_addr sixrd_prefix, pd_prefix;
         const struct in_addr *br_addresses;
         struct in_addr ipv4address;
-        uint32_t lifetime_sec;
-        usec_t lifetime_usec, now_usec;
+        usec_t lifetime_usec;
         int r;
 
         assert(link);
@@ -868,13 +860,10 @@ static int dhcp4_pd_assign_subnet_prefix(Link *link, Link *uplink) {
         if (r < 0)
                 return log_link_warning_errno(uplink, r, "Failed to get DHCPv4 address: %m");
 
-        r = sd_dhcp_lease_get_lifetime(uplink->dhcp_lease, &lifetime_sec);
+        r = sd_dhcp_lease_get_lifetime_timestamp(uplink->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
         if (r < 0)
                 return log_link_warning_errno(uplink, r, "Failed to get lifetime of DHCPv4 lease: %m");
 
-        assert_se(sd_event_now(uplink->manager->event, CLOCK_BOOTTIME, &now_usec) >= 0);
-        lifetime_usec = sec_to_usec(lifetime_sec, now_usec);
-
         r = sd_dhcp_lease_get_6rd(uplink->dhcp_lease, &ipv4masklen, &sixrd_prefixlen, &sixrd_prefix, &br_addresses, NULL);
         if (r < 0)
                 return log_link_warning_errno(uplink, r, "Failed to get DHCPv4 6rd option: %m");
@@ -929,8 +918,7 @@ int dhcp4_pd_prefix_acquired(Link *uplink) {
         struct in_addr ipv4address;
         union in_addr_union server_address;
         const struct in_addr *br_addresses;
-        uint32_t lifetime_sec;
-        usec_t lifetime_usec, now_usec;
+        usec_t lifetime_usec;
         Link *link;
         int r;
 
@@ -942,13 +930,10 @@ int dhcp4_pd_prefix_acquired(Link *uplink) {
         if (r < 0)
                 return log_link_warning_errno(uplink, r, "Failed to get DHCPv4 address: %m");
 
-        r = sd_dhcp_lease_get_lifetime(uplink->dhcp_lease, &lifetime_sec);
+        r = sd_dhcp_lease_get_lifetime_timestamp(uplink->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
         if (r < 0)
                 return log_link_warning_errno(uplink, r, "Failed to get lifetime of DHCPv4 lease: %m");
 
-        assert_se(sd_event_now(uplink->manager->event, CLOCK_BOOTTIME, &now_usec) >= 0);
-        lifetime_usec = sec_to_usec(lifetime_sec, now_usec);
-
         r = sd_dhcp_lease_get_server_identifier(uplink->dhcp_lease, &server_address.in);
         if (r < 0)
                 return log_link_warning_errno(uplink, r, "Failed to get server address of DHCPv4 lease: %m");
@@ -1148,10 +1133,7 @@ static bool dhcp4_pd_uplink_is_ready(Link *link) {
         if (sd_dhcp_client_is_running(link->dhcp_client) <= 0)
                 return false;
 
-        if (!link->dhcp_lease)
-                return false;
-
-        return dhcp4_lease_has_pd_prefix(link->dhcp_lease);
+        return sd_dhcp_lease_has_6rd(link->dhcp_lease);
 }
 
 static bool dhcp6_pd_uplink_is_ready(Link *link) {
diff --git a/src/network/networkd-dhcp-prefix-delegation.h b/src/network/networkd-dhcp-prefix-delegation.h
index d67f919ba7..b12e985bec 100644
--- a/src/network/networkd-dhcp-prefix-delegation.h
+++ b/src/network/networkd-dhcp-prefix-delegation.h
@@ -13,7 +13,6 @@ typedef struct Link Link;
 bool link_dhcp_pd_is_enabled(Link *link);
 bool dhcp_pd_is_uplink(Link *link, Link *target, bool accept_auto);
 int dhcp_pd_find_uplink(Link *link, Link **ret);
-bool dhcp4_lease_has_pd_prefix(sd_dhcp_lease *lease);
 bool dhcp6_lease_has_pd_prefix(sd_dhcp6_lease *lease);
 int dhcp_pd_remove(Link *link, bool only_marked);
 int dhcp_request_prefix_delegation(Link *link);
diff --git a/src/network/networkd-dhcp4.c b/src/network/networkd-dhcp4.c
index f952d6dfbc..a3f28035d7 100644
--- a/src/network/networkd-dhcp4.c
+++ b/src/network/networkd-dhcp4.c
@@ -839,7 +839,7 @@ int dhcp4_lease_lost(Link *link) {
         link->dhcp4_configured = false;
 
         if (link->network->dhcp_use_6rd &&
-            dhcp4_lease_has_pd_prefix(link->dhcp_lease))
+            sd_dhcp_lease_has_6rd(link->dhcp_lease))
                 dhcp4_pd_prefix_lost(link);
 
         k = dhcp4_remove_address_and_routes(link, /* only_marked = */ false);
@@ -910,15 +910,9 @@ static int dhcp4_request_address(Link *link, bool announce) {
                 return log_link_debug_errno(link, r, "DHCP error: failed to get DHCP server IP address: %m");
 
         if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
-                uint32_t lifetime_sec;
-                usec_t now_usec;
-
-                r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime_sec);
+                r = sd_dhcp_lease_get_lifetime_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
                 if (r < 0)
-                        return log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
-
-                assert_se(sd_event_now(link->manager->event, CLOCK_BOOTTIME, &now_usec) >= 0);
-                lifetime_usec = sec_to_usec(lifetime_sec, now_usec);
+                        return log_link_warning_errno(link, r, "DHCP error: failed to get lifetime: %m");
         } else
                 lifetime_usec = USEC_INFINITY;
 
@@ -1033,11 +1027,11 @@ static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
         link_dirty(link);
 
         if (link->network->dhcp_use_6rd) {
-                if (dhcp4_lease_has_pd_prefix(link->dhcp_lease)) {
+                if (sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
                         r = dhcp4_pd_prefix_acquired(link);
                         if (r < 0)
                                 return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
-                } else if (dhcp4_lease_has_pd_prefix(old_lease))
+                } else if (sd_dhcp_lease_has_6rd(old_lease))
                         dhcp4_pd_prefix_lost(link);
         }
 
@@ -1107,7 +1101,7 @@ static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
         }
 
         if (link->network->dhcp_use_6rd &&
-            dhcp4_lease_has_pd_prefix(link->dhcp_lease)) {
+            sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
                 r = dhcp4_pd_prefix_acquired(link);
                 if (r < 0)
                         return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
@@ -1617,8 +1611,8 @@ static int dhcp4_configure(Link *link) {
                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set socket priority: %m");
         }
 
-        if (link->network->dhcp_fallback_lease_lifetime > 0) {
-                r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime);
+        if (link->network->dhcp_fallback_lease_lifetime_usec > 0) {
+                r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime_usec);
                 if (r < 0)
                         return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed set to lease lifetime: %m");
         }
@@ -1877,7 +1871,7 @@ int config_parse_dhcp_fallback_lease_lifetime(
         assert(data);
 
         if (isempty(rvalue)) {
-                network->dhcp_fallback_lease_lifetime = 0;
+                network->dhcp_fallback_lease_lifetime_usec = 0;
                 return 0;
         }
 
@@ -1888,7 +1882,7 @@ int config_parse_dhcp_fallback_lease_lifetime(
                 return 0;
         }
 
-        network->dhcp_fallback_lease_lifetime = UINT32_MAX;
+        network->dhcp_fallback_lease_lifetime_usec = USEC_INFINITY;
 
         return 0;
 }
diff --git a/src/network/networkd-json.c b/src/network/networkd-json.c
index 92a086af64..1e425fcb29 100644
--- a/src/network/networkd-json.c
+++ b/src/network/networkd-json.c
@@ -1131,8 +1131,7 @@ static int dhcp6_client_append_json(Link *link, JsonVariant **v) {
 
 static int dhcp_client_lease_append_json(Link *link, JsonVariant **v) {
         _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
-        uint32_t t1, t2;
-        uint64_t lease_timestamp_usec;
+        usec_t lease_timestamp_usec, t1, t2;
         int r;
 
         assert(link);
@@ -1141,24 +1140,22 @@ static int dhcp_client_lease_append_json(Link *link, JsonVariant **v) {
         if (!link->dhcp_client || !link->dhcp_lease)
                 return 0;
 
-        r = sd_dhcp_lease_get_t1(link->dhcp_lease, &t1);
+        r = sd_dhcp_lease_get_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &lease_timestamp_usec);
         if (r < 0)
                 return 0;
 
-        r = sd_dhcp_lease_get_t2(link->dhcp_lease, &t2);
+        r = sd_dhcp_lease_get_t1_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &t1);
         if (r < 0)
                 return 0;
 
-        r = sd_dhcp_client_get_lease_timestamp(link->dhcp_client, &lease_timestamp_usec);
+        r = sd_dhcp_lease_get_t2_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &t2);
         if (r < 0)
                 return 0;
 
         r = json_build(&w, JSON_BUILD_OBJECT(
-                                JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec",
-                                                            sec_to_usec(t1, lease_timestamp_usec)),
-                                JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec",
-                                                            sec_to_usec(t2, lease_timestamp_usec)),
-                                JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", lease_timestamp_usec)));
+                                JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", lease_timestamp_usec),
+                                JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec", t1),
+                                JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec", t2)));
         if (r < 0)
                 return r;
 
@@ -1177,7 +1174,7 @@ static int dhcp_client_pd_append_json(Link *link, JsonVariant **v) {
         assert(link->network);
         assert(v);
 
-        if (!link->network->dhcp_use_6rd || !link->dhcp_lease || !dhcp4_lease_has_pd_prefix(link->dhcp_lease))
+        if (!link->network->dhcp_use_6rd || !sd_dhcp_lease_has_6rd(link->dhcp_lease))
                 return 0;
 
         r = sd_dhcp_lease_get_6rd(link->dhcp_lease, &ipv4masklen, &sixrd_prefixlen, &sixrd_prefix, &br_addresses, &n_br_addresses);
diff --git a/src/network/networkd-link.c b/src/network/networkd-link.c
index d4a72e2ec5..eea47f6c8c 100644
--- a/src/network/networkd-link.c
+++ b/src/network/networkd-link.c
@@ -477,7 +477,7 @@ void link_check_ready(Link *link) {
         /* If the uplink for PD is self, then request the corresponding DHCP protocol is also ready. */
         if (dhcp_pd_is_uplink(link, link, /* accept_auto = */ false)) {
                 if (link_dhcp4_enabled(link) && link->network->dhcp_use_6rd &&
-                    link->dhcp_lease && dhcp4_lease_has_pd_prefix(link->dhcp_lease)) {
+                    sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
                         if (!dhcp4_ready)
                                 return (void) log_link_debug(link, "%s(): DHCPv4 6rd prefix is assigned, but DHCPv4 protocol is not finished yet.", __func__);
                         if (!dhcp_pd_ready)
diff --git a/src/network/networkd-network.h b/src/network/networkd-network.h
index 3e1110e6d7..98cc1f5abc 100644
--- a/src/network/networkd-network.h
+++ b/src/network/networkd-network.h
@@ -127,7 +127,7 @@ struct Network {
         bool dhcp_route_metric_set;
         uint32_t dhcp_route_table;
         bool dhcp_route_table_set;
-        uint32_t dhcp_fallback_lease_lifetime;
+        usec_t dhcp_fallback_lease_lifetime_usec;
         uint32_t dhcp_route_mtu;
         uint16_t dhcp_client_port;
         int dhcp_critical;
diff --git a/src/systemd/sd-dhcp-client.h b/src/systemd/sd-dhcp-client.h
index 45ab8765d2..95ff829af3 100644
--- a/src/systemd/sd-dhcp-client.h
+++ b/src/systemd/sd-dhcp-client.h
@@ -318,7 +318,7 @@ int sd_dhcp_client_set_socket_priority(
                 int so_priority);
 int sd_dhcp_client_set_fallback_lease_lifetime(
                 sd_dhcp_client *client,
-                uint32_t fallback_lease_lifetime);
+                uint64_t fallback_lease_lifetime);
 
 int sd_dhcp_client_add_option(sd_dhcp_client *client, sd_dhcp_option *v);
 int sd_dhcp_client_add_vendor_option(sd_dhcp_client *client, sd_dhcp_option *v);
@@ -329,7 +329,6 @@ int sd_dhcp_client_start(sd_dhcp_client *client);
 int sd_dhcp_client_send_release(sd_dhcp_client *client);
 int sd_dhcp_client_send_decline(sd_dhcp_client *client);
 int sd_dhcp_client_send_renew(sd_dhcp_client *client);
-int sd_dhcp_client_get_lease_timestamp(sd_dhcp_client *client, uint64_t *timestamp);
 
 sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client);
 sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client);
diff --git a/src/systemd/sd-dhcp-lease.h b/src/systemd/sd-dhcp-lease.h
index 8a27059572..1ef53ccf1e 100644
--- a/src/systemd/sd-dhcp-lease.h
+++ b/src/systemd/sd-dhcp-lease.h
@@ -47,9 +47,13 @@ __extension__ typedef enum sd_dhcp_lease_server_type_t {
 } sd_dhcp_lease_server_type_t;
 
 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr);
-int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime);
-int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1);
-int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2);
+int sd_dhcp_lease_get_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
+int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint64_t *ret);
+int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint64_t *ret);
+int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint64_t *ret);
+int sd_dhcp_lease_get_lifetime_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
+int sd_dhcp_lease_get_t1_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
+int sd_dhcp_lease_get_t2_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
 int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr);
 int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr);
 int sd_dhcp_lease_get_prefix(sd_dhcp_lease *lease, struct in_addr *ret_prefix, uint8_t *ret_prefixlen);
@@ -81,6 +85,7 @@ int sd_dhcp_lease_get_6rd(
                 struct in6_addr *ret_prefix,
                 const struct in_addr **ret_br_addresses,
                 size_t *ret_n_br_addresses);
+int sd_dhcp_lease_has_6rd(sd_dhcp_lease *lease);
 
 int sd_dhcp_route_get_destination(sd_dhcp_route *route, struct in_addr *destination);
 int sd_dhcp_route_get_destination_prefix_length(sd_dhcp_route *route, uint8_t *length);