
<p class="has-drop-cap wp-block-paragraph">1 Statligt ägda skandalomsusade Norsk Tipping – motsvarigheten till Svenska Spel – har hamnat ordentligt i blåsväder – igen!. Bolagets direktör Tonje Sagstuen fick sparken av styrelsen i lördags sedan 400.000 norska personer – ja, Ni läste rätt! – fått felaktigt meddelande om att de vunnit miljonbelopp på Eurojackpot.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/skarmavbild20250629kl.17.46.09-617x432.jpg" alt="" class="wp-image-737275"/><figcaption class="wp-element-caption">Norsk Tippings direktör Tonje Sagstuen fick sparken i lördags.</figcaption></figure>



<p class="wp-block-paragraph">Norsk Tippning ligger under kulturdepartementet i Norge och fredagens skandal – skriver <a href="https://tgn.no/aktuelt/tippesjefen-tonje-sagstuen-matte-ga-hva-gjor-rikstoto-na/19.29290" data-type="link" data-id="https://tgn.no/aktuelt/tippesjefen-tonje-sagstuen-matte-ga-hva-gjor-rikstoto-na/19.29290" target="_blank" rel="noreferrer noopener">Trav-og Galopp-Nytt</a> – fick kulturminister Lubna Jaffery (Arbeiderpartiet) att ta bladet från munnen och kallade till sig styrelseordförande Sylvia Brustad. En enig styrelse beslutade att plocka bort Tonje Sagstue.</p>



<p class="wp-block-paragraph">Semesterresor har bokats och champagneflaskor har öppnats, men det var för bra för att vara sant, skriver Verdens Gang. </p>



<p class="wp-block-paragraph">I ett pressmeddelande i fredags kväll skrev Norsk Tipping bland annat:</p>



<p class="wp-block-paragraph"><em>”Norsk Tipping tar emot beloppen från Tyskland i eurocent och omvandlar dem sedan till norska kronor. Under denna konvertering gjordes ett manuellt fel i den kod som matades in i vår spelmotor. Beloppet har multiplicerats med 100 istället för att divideras med 100.”</em></p>



<p class="wp-block-paragraph">Enligt avgående direktören Tonje Sagstuen hade inga vinstpengar betalats ut.</p>



<p class="wp-block-paragraph">Norsk Rikstoto – motsvarigheten till ATG – och Norsk Tipping har under den senaste tiden haft täta möten och förhandlingar om ett framtida samarbete. Kanske dags att låta samarbetet ligga på is tills vidare med tanke på att Norsk Tipping tidigare fått miljonböter vid flera tillfällen och även haft felaktiga utbetalningar…?</p>



<p class="wp-block-paragraph">Vad som händer med samarbetet återstår att se&#8230;Rikstotos styrelseordförande Erik Röste har fått flera dagar på sig att svara på tre frågor från Trav-og Galopp-Nytt, men har valt att inte göra det:</p>



<ul class="wp-block-list">
<li>Vad anser Norsk Rikstoto om alla de felaktigheter som uppdagats hos Norsk Tipping?</li>



<li>Har dessa frågor någon inverkan på de pågående förhandlingarna mellan NR och NT?</li>



<li>Vad kommer Tonje Sagstunens avgång att betyda för förhandlingarna mellan NT och NR?</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 Tre segrar på sex försök hos Robert Bergh som treåring. Sedan försvann finskfödde <strong>Plucky Swamp</strong> (e. Googoo Gaagaa) från tävlingsbanan i över 1,5 år. I februari var han tillbaka på banan i kvallopp och 616 dagar efter senaste segern vann han igen på Bergsåker i april i sin comeback.</p>



<p class="wp-block-paragraph">Efter två segrar och ett andrapris under våren dyker Plucky Swamp upp i ett dubbelklasslopp på måndagens huvudbana <strong>Färjestad</strong> (första start 18.20). Rikard N Skoglund hoppar upp i vagnen för första gången bakom den högkapable fyraåringen.</p>



<p class="wp-block-paragraph">I övrigt på Karlstadbanan? I ett treåringslopp gör två debutvinnare med Maharajah som pappa karriärens andra starter, Björn Goops <strong>I’m A Dancer</strong> och Hans Crebas-tränade <strong>Joakim Palema</strong>, och dessa ställs mot <strong>Perfect Chest</strong> (e. Perfect Spirit), som avlade maiden i livets andra start.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3 Tre svenska banor tävlar veckans första dag och först ut är <strong>Kalmar</strong> (start 12.20) med lunchtävlingar och en storloppsvinnare i comeback. </p>



<p class="wp-block-paragraph">2017 vann <strong>Maze Runner</strong> (e. G.H.Nemo), då i träning hos Marcus Lindgren, Örebros stora tvååringslopp Svampen tillsammans med Johnny Takter. Segerchecken var 537.000 kronor.<br>Sedan dess är dubbla segrar i silverdivisionen främsta meriterna för tioåringen, som inför 2022 års säsong lämnade Sverige. Nu är han tillbaka i Robert och Emma Kerttus regi i Halmstad och efter 16 månaders tävlingsuppehåll gör han comeback från tillägg i ett sprinterlopp med flera goda motståndare.<br>Totalt har dubbelmiljonären gjort 62 starter (8-15-6).</p>



<p class="wp-block-paragraph">Kvällen kompletteras med tävlingar i <strong>Rättvik</strong> (start 18.30) och där ska Dalarnas bästa kusk koras. Kuskmatchen Dalamästaren ser de fem segerrikaste proffstränarna på Romme/Rättvik, de fem segerrikaste B- och K-licensierade kuskarna födda 1994 eller tidigare samt fem kuskar födda 1995 eller senare göra upp i ett lopp.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4 Familjen Nimczyk – Michael och Wolfgang – vann båda upplagorna av Adbell-Toddington-Rennen för fyraåringar på Mariendorf-banan i Berlin med Aladin respektive Sahara Firebird.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/skarmavbild20250629kl.19.23.48-617x293.jpg" alt="" class="wp-image-737282"/><figcaption class="wp-element-caption">Aladin räknar in sin nionde raka seger för Michael Nimczyk.</figcaption></figure>



<p class="wp-block-paragraph">I den öppna avdelningen av Adbell-Toddington-Rennen (€20.000) blev det favoritvinst för <strong>Aladin</strong> (e. Baltimore As-Aint She Sweet), men han hade långt fram till ledaren när attacken sattes in i tredjespår vid ingången till sista sväng.</p>



<p class="wp-block-paragraph">På upploppet hade Aladin bästa spurtkrutet och vann säkert på 1.12,2a/1.900 meter. Fyraåringen är obesegrad i nio starter!</p>



<p class="wp-block-paragraph">Bland tidigare segrar märks Dreijährigen Kriterium (€50.000) och Breeders Crown (€23.674). Modern <strong>Ain’t She Sweet</strong> (e. Pablo As), 1.14,5/€19.086, är halvsyster med Prix d’Amérique-vinnaren <strong>Abano As</strong> (e. Dylan Lobell), 1.10,2/€2.197.479, och i samma syskonskara ingår också <strong>Ambassador As</strong> (€360.487), <strong>Armstrong As </strong>(€160.420) och <strong>Admiral As</strong> (€118.730).</p>



<p class="wp-block-paragraph">Stonas uppgörelse i Adbell-Toddington-Rennen (€10.000) gick till <strong>Sahara Firebird </strong>(e. Googoo Gaagaa-Votum Deo) och Michael Nimczyk. Duon reste i andra ytter, tog sats i tredjespår i sista sväng och kopplade greppet tidigt på upploppet. Vinnartiden skrevs till 1.13,9a/1.900 meter.</p>



<p class="wp-block-paragraph">Ifjol vann Sahara Firebird Auktions-Rennenn (€20.000) i Berlin. Stoet såldes på den tyska Derbyauktionen som ettåring för 14.000 euro. Hon är undan ostartade <strong>Votum Deo </strong>(e. Like A Prayer), vilken har sin främsta avkomma i <strong>Vegas Deo</strong> (e. Cantab Hall), 1.13,0/$58.060.</p>



<p class="wp-block-paragraph">Votum Deo är i sin tur helsyster med <strong>Godiva Hall</strong>, 1.09,9/$818.475, och i samma syskongrupp ingår också <strong>Highland Mowgli </strong>(e. Archangel), 1.10,1/$391.907, och <strong>Golden Genes Hall (</strong>e. Striking Sahbra), 1.13,0/$125.059.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 Första försöket i Super Trot Cup (€15.000) gick till unghäststjärnan <strong>Zoom Diamant </strong>(e. Maharajah-Keystone Tabby) och Robin Bakker efter en resa i andra ytter. Den Paul Hagoort-tränade femåringen vann på 1.11,3a/1.900 meter före Django Hill (e. Muscle Hill) och Uccellone (e. Corleone), som noterade 1.11,5 respektive 1.11,9.</p>



<p class="wp-block-paragraph">Förra året vann Zoom Diamant två av Triple Crown-lopp – Adbell-Toddington-Rennen (€25.000) och Buddenbrock-Rennen (€20.000) – plus att han tog hem Tyskt Breeders Crown (€29.568). I år har han också vunnit Bild-Pokal (€20.000) i Gelsenkirchen och nämnas ska också hans största seger som treåring; finalen i Dreijährigen Series (€50.000).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6 Två segrar och lika många starter har det blivit för Marcus Melanders <strong>Periculum</strong> (e. Muscle Hill), 1.08,0/$1.433.376, vilken var den vinstrikaste äldre manliga travaren i USA förra året.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/periculum2862025lisa-617x346.jpg" alt="" class="wp-image-737148"/><figcaption class="wp-element-caption">Periculum vid lördagens vinst på Meadowlands för Scott Zeron på 1.08,4. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">I lördags tangerade han världsårsbästa – 1.08,4 – när han vann <a href="https://sulkysport.se/tangerade-varldsarsbasta-6/" data-type="link" data-id="https://sulkysport.se/tangerade-varldsarsbasta-6/" target="_blank" rel="noreferrer noopener">Crawford Farms </a>($164.000) på Meadowlands och i årsdebuten tog han hem Arthur J. Cutler Memorial ($158.000) på samma bana.</p>



<p class="wp-block-paragraph">– Det är inte så mycket lopp för hästarna i hans klass tidigt på säsongen. Nästa lopp är Spirit of Massachesetts ($250.000) på Plainridge Park om tre veckor och därefter John Cashman Memorial ($300.000) den 2 augusti på Meadowlands, berättar Marcus Melander.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 Perry och Annlee Söderberg kan rapportera om två stoföl från andra sidan Atlanten. Svenskfödda och ostartade <strong>Superfreak</strong> (e. Bold Eagle-Jacky Glide) har fått en dotter efter Volume Eight.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/superfreak-617x886.jpg" alt="" class="wp-image-737189"/><figcaption class="wp-element-caption">Superfreaks dotter efter Volume Eight. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Modern är undan <strong>Jacky Glide</strong> (e. Jag de Bellouet), 1.12,2am/2.028.467 kr, och ingår i samma syskonskara som avelshingsten, SM-ettan och världsrekordhållaren <strong>Very Kronos </strong>(e. Ready Cash), 1.10,7ak/7.322.559 kr, Breeders Crown-vinnaren <strong>Treasure Kronos</strong> (e. Raja Mirchi), 1.09,7ak/4.964.492 kr, och <strong>Oliver Kronos</strong> (e. Varenne), 1.11,6am/2.187.631 kr.</p>



<p class="wp-block-paragraph"><strong>Urban Legend </strong>(e. Muscle Hill-Bedtime Story), 1.09,8/$35.550, har fått ett sto efter Ecurie D. och sedan tidigare har hon två startande avkommor; treårige <strong>Boots N Beer</strong> (e. Greenshoe), 1.11,8/$40.870, och <strong>Times Like This </strong>(e. Father Patrick), 1.12,1/$18.518.</p>



<p class="wp-block-paragraph">Mormor Bedtime Song ingår i samma syskonskara som <strong>Pampered Princess</strong> ($1.740.605) och <strong>Was It A Dream </strong>($824.457).</p>



<p class="wp-block-paragraph">– Båda stona går till Rattle My Cage i år, berättar Perry Söderberg.</p>



<p class="wp-block-paragraph">Leif Karlsson kan också berätta att <strong>Idreamicanfly</strong> (e. Adrian Chip-Red Hot Dream), 1.12,1ak*/497.300 kr, har fått en hingst efter Bold Eagle.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/idreamicanfly-617x463.jpeg" alt="" class="wp-image-737190"/><figcaption class="wp-element-caption">Idreamicanflys hingst efter Bold Eagle. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">– Ny hingst i år är inte definitivt bestämd, men blir troligtvis Ambassador Hanover, meddelar Leif Karlsson.</p>



<p class="wp-block-paragraph">Två avkommor har Idreamicanfly och det handlar om treårige <strong>Superfly</strong> (e. Fabulous Wood) och ett år yngre <strong>My Butterfly</strong> (e. Maharajah). Mormor <strong>Red Hot Dream</strong> (e. Dream Lover), 1.13,2ak/685.750 kr, har sin främsta avkomma i <strong>Hope and Dreams</strong> (e. Triton Sund), 1.12,1ak/1.248.064 kr.</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Samarbete spricker efter spelskandal?
Vad händer efter norska spelskandalen? Tre svenska banor tävlar idag. Obesegrad tysk i nio starter. Unghäststjärna vann Super Trot Cup-försök. Nyfött på båda sidor om Atlanten.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
