 src/platform/nm-linux-platform.c | 51 +++++++++++++++++++++++++--------------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git i/src/platform/nm-linux-platform.c w/src/platform/nm-linux-platform.c
index d2ab39a..8ab8bbc 100644
--- i/src/platform/nm-linux-platform.c
+++ w/src/platform/nm-linux-platform.c
@@ -82,49 +82,49 @@ G_DEFINE_TYPE (NMLinuxPlatform, nm_linux_platform, NM_TYPE_PLATFORM)
 static const char *to_string_object (NMPlatform *platform, struct nl_object *obj);
 
 void
 nm_linux_platform_setup (void)
 {
 	nm_platform_setup (NM_TYPE_LINUX_PLATFORM);
 }
 
 /******************************************************************/
 
-static gint64
-_clock_gettime_ns ()
+static gint32
+_clock_gettime_s ()
 {
 	struct timespec tp;
 
 	clock_gettime (CLOCK_MONOTONIC, &tp);
-	return ((gint64) tp.tv_sec) * NM_UTILS_NS_PER_SECOND + ((gint64) tp.tv_nsec);
+	return ((gint64) tp.tv_sec) * NM_UTILS_NS_PER_SECOND;
 }
 
-/* convert the timestamp from ifa_cacheinfo to CLOCK_MONOTONIC nanoseconds. */
+/* convert the timestamp from ifa_cacheinfo to CLOCK_MONOTONIC seconds. */
 static gint64
-_timestamp_nl_to_ns (gint64 timestamp_nl, gint64 monotonic_ns)
+_timestamp_nl_to_s (gint64 timestamp_nl, gint64 monotonic_s)
 {
-	const gint64 WRAP_INTERVAL = (((gint64) G_MAXUINT32) + 1) * (NM_UTILS_NS_PER_SECOND / 100);
+	const gint64 WRAP_INTERVAL = (((gint64) G_MAXUINT32) + 1) / 100;
 
-	/* convert timestamp to nsec. */
-	timestamp_nl *= (NM_UTILS_NS_PER_SECOND / 100);
+	/* convert timestamp to sec. */
+	timestamp_nl /= 100;
 
 	/* timestamp wraps every 497 days. Try to compensate for that.*/
-	if (timestamp_nl > monotonic_ns) {
+	if (timestamp_nl > monotonic_s) {
 		/* timestamp_nl is in the future. Truncate it to *now* */
-		timestamp_nl = monotonic_ns;
-	} else if (monotonic_ns >= WRAP_INTERVAL) {
-		timestamp_nl += (monotonic_ns / WRAP_INTERVAL) * WRAP_INTERVAL;
-		if (timestamp_nl > monotonic_ns)
+		timestamp_nl = monotonic_s;
+	} else if (monotonic_s >= WRAP_INTERVAL) {
+		timestamp_nl += (monotonic_s / WRAP_INTERVAL) * WRAP_INTERVAL;
+		if (timestamp_nl > monotonic_s)
 			timestamp_nl -= WRAP_INTERVAL;
 	}
 
-	g_assert (timestamp_nl >= 0 && timestamp_nl <= monotonic_ns);
+	g_assert (timestamp_nl >= 0 && timestamp_nl <= monotonic_s);
 
 	return timestamp_nl;
 }
 
 static guint32
 _extend_lifetime (guint32 lifetime, guint64 shift_s)
 {
 	guint64 t;
 
 	if (lifetime == NM_PLATFORM_LIFETIME_PERMANENT)
@@ -143,36 +143,36 @@ _extend_lifetime (guint32 lifetime, guint64 shift_s)
  * However, the preferred and lifetime counters start ticking *now*. As we cache the
  * libnl structure, we have to base these relative times on last_update_time.
  **/
 static void
 _normalize_timestamps (struct rtnl_addr *rtnladdr)
 {
 	guint32 a_preferred = rtnl_addr_get_preferred_lifetime (rtnladdr);
 	guint32 a_lifetime  = rtnl_addr_get_valid_lifetime (rtnladdr);
 	gint64 a_timestamp;
 	guint64 shift_s;
-	gint64 now;
+	gint32 now;
 
 	if (a_preferred == NM_PLATFORM_LIFETIME_PERMANENT &&
 	    a_lifetime == NM_PLATFORM_LIFETIME_PERMANENT)
 		return;
 
-	now = _clock_gettime_ns ();
+	now = _clock_gettime_s ();
 
-	a_timestamp = _timestamp_nl_to_ns (rtnl_addr_get_last_update_time (rtnladdr), now);
+	a_timestamp = _timestamp_nl_to_s (rtnl_addr_get_last_update_time (rtnladdr), now);
 
 	/* calculate offset in seconds. It holds that: 0 <= a_timestamp <= now
 	 *
 	 * We cannot modify the last_update_time of rtnladdr, only the lifetime with
 	 * a precision of seconds. Thus we loose here some precision. As mitigation,
 	 * round shift_s */
-	shift_s = (now - a_timestamp + (NM_UTILS_NS_PER_SECOND/2)) / NM_UTILS_NS_PER_SECOND;
+	shift_s = now - a_timestamp;
 
 	rtnl_addr_set_valid_lifetime (rtnladdr, _extend_lifetime (a_lifetime, shift_s));
 	rtnl_addr_set_preferred_lifetime (rtnladdr, _extend_lifetime (a_preferred, shift_s));
 }
 
 /******************************************************************/
 
 /* libnl library workarounds and additions */
 
 /* Automatic deallocation of local variables */
@@ -955,40 +955,39 @@ hack_empty_master_iff_lower_up (NMPlatform *platform, struct nl_object *object)
 	}
 
 	rtnl_link_unset_flags (rtnllink, IFF_LOWER_UP);
 }
 
 static void
 _rtnladdr_get_timestamp (struct rtnl_addr *rtnladdr, guint32 *out_timestamp, guint32 *out_lifetime, guint32 *out_preferred)
 {
 	guint32 a_preferred = rtnl_addr_get_preferred_lifetime (rtnladdr);
 	guint32 a_lifetime  = rtnl_addr_get_valid_lifetime (rtnladdr);
-	gint64 a_timestamp;
-	gint64 monotonic_ns;                /* clock_gettime (CLOCK_MONOTONIC); */
-	gint64 monotonic_timestamp_ns;      /* nm_utils_get_monotonic_timestamp_ns () */
+	gint32 a_timestamp;
+	gint32 monotonic_s;                /* clock_gettime (CLOCK_MONOTONIC); */
+	gint32 monotonic_timestamp_s;      /* nm_utils_get_monotonic_timestamp_s () */
 
 	if (a_preferred == NM_PLATFORM_LIFETIME_PERMANENT &&
 	    a_lifetime == NM_PLATFORM_LIFETIME_PERMANENT) {
 		*out_timestamp = 0;
 		*out_lifetime = NM_PLATFORM_LIFETIME_PERMANENT;
 		*out_preferred = NM_PLATFORM_LIFETIME_PERMANENT;
 	}
 
-	monotonic_ns = _clock_gettime_ns ();
-	monotonic_timestamp_ns = nm_utils_get_monotonic_timestamp_ns ();
-	monotonic_ns = (_clock_gettime_ns () + monotonic_ns) / 2;
+	monotonic_s = _clock_gettime_s ();
+	monotonic_timestamp_s = nm_utils_get_monotonic_timestamp_s ();
 
 	/* get the last_update_time() of the address in nsec of CLOCK_MONOTONIC. */
-	a_timestamp = _timestamp_nl_to_ns (rtnl_addr_get_last_update_time (rtnladdr), monotonic_ns);
+	a_timestamp = _timestamp_nl_to_s (rtnl_addr_get_last_update_time (rtnladdr), monotonic_s);
 
 	/* convert a_timestamp to nm_utils_get_monotonic_timestamp_s () */
-	a_timestamp = (a_timestamp + (monotonic_timestamp_ns - monotonic_ns)) / NM_UTILS_NS_PER_SECOND;
+	a_timestamp = (a_timestamp + (monotonic_timestamp_s - monotonic_s));
 
 	if (a_timestamp <= 0) {
 		/* the address existed before the start of NM, so the timestamp in
 		 * get_monotonic_timestamp_s() scale would be non-positive. Adjust the
 		 * lifetime accordingly. */
 
 		if (a_lifetime != NM_PLATFORM_LIFETIME_PERMANENT)
 			a_lifetime = MAX (0, a_lifetime + a_timestamp - 1);
 		if (a_preferred != NM_PLATFORM_LIFETIME_PERMANENT)
 			a_preferred = MAX (0, a_preferred + a_timestamp - 1);
