AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
AKKURAT NÅ:
VG:
-
VG: Astrid Hoem gir seg som AUF-leder
-
Reuters og AP: Ukraina har brukt langdistanseraketter som i all hemmelighet er sendt fra USA
-
Varsler forsinkelser ved franske flyplasser
-
Rapper dømt til døden
-
Israel: Starter Rafah-operasjon «umiddelbart»
-
FHI: Kvinner lider - menn dør
-
Wales: Skole stengt ned flere skadd
-
Barth Eide om vold på Vestbredden: - Dypt bekymret
-
Syklist påkjørt i fotgjengerfelt
-
Advarer bilister
Russland: Advarerinnbyggerne
Effektivt mot rynker:Eneste som funker
Annonsørinnhold
Viktig 3-1 seieri gullkampen
i samarbeid med NorskSvenske Lars(81) vil ha barn
Fikk ALS -skal dø snart
Annonsørinnhold
Se din boligverdigratis her
i samarbeid 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