AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
AKKURAT NÅ:
ISRAEL ANGREP IRAN:
-
Interfax: Strategisk bombefly har styrtet i Russland
-
Iran: Fly på vei fra Dubai snudde
-
To pågrepet etter pistolfunn
-
Medier: Israelske raketter mot Iran
-
Drapssiktet varetektsfengslet
-
Tiltalt for seksuelle overgrep mot datter
-
Stjal politiets lasermåler
-
USA la ned veto i Sikkerhetsrådet mot palestinsk FN-medlemskap
-
Kvinne siktet for drapsforsøk
-
Ektemannen til Skottlands tidligere førsteminister pågrepet - igjen
Tinnitus-formelen:Frisk i rekordfart
Norske bilderskaper rabalder
Annonsørinnhold
2024: Vant 1,36milliarder!
i samarbeid med NorskNormal-eierensmareritt: - Flere døde
Banksjokk:- Han er død
Annonsørinnhold
Denne rentenhar du krav på
i samarbeid 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