-
Pårørende på Torpo: - Fylt av bunnløs sorg
-
Dykkerulykke i Lindesnes
-
Fikk tre over seg - omkom
-
Skytingen på Tøyen: Siktet samtykker til to ukers varetektsfengsling
-
Ukraina-angrep: Nato-fly på vingene
-
Trafikk: Hardangervidda er åpen
-
Stavern: Melding om båtbrann var grilling
-
Syria: - Sivile og soldater drept i israelsk angrep
-
Ukraina: Russisk angrep mot Dnipro
-
Målselv: Fløyet til sykehus etter trafikkulykke
Tar av
Supergrepet: Annette(52) raste ned i vekt
Annonsørinnhold
I kveld kan duvinne 534 millioner
i samarbeid med NorskKollapserunder maraton
Batteridrevne motorsager:Vinnerne latterlig billig!
Annonsørinnhold
Europas svarpå Dubai
i samarbeid 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