
<p class="has-drop-cap">1Ett anrikt treåringslopp för ston på Axevalla är söndagens höjdpunkt. Guldstoet avgjordes för första gången 1972 och i eftermiddag på Stochampionatsbanan är det dags för årets upplaga med 350.000 kronor till vinnaren.<br>Att vinna Axevallas två största lopp för ston, Guldstoet och Stochampionatet, har bara fyra damer lyckats med i historien. Och det är ingen dålig kvartett! Eller vad sägs om <strong>Ina Scot, Lovely Godiva, Lie Detector</strong> och <strong>Viola Silas</strong>!</p>



<p>När Ina Scot och Lovely Godiva segrade i Guldstoet i början av 1990-talet avgjordes loppet i december, men sedan 2001 har loppet hittat sin plats första veckan i juni.<br>Förra året blev det seger för Petri Salmela-tränade <strong>Kobra Brick</strong> (e. Readly Express), som följde upp med att vinna långa E3 och Breeders Crown. De meriterna tog henne till titeln Årets Treåring på hästgalan i vintras. Efter andraplatsen i Ina Scots Ära i Mantorp igår laddas Kobra Brick vidare mot Stochampionatet.</p>



<p>Årets upplaga av Guldstoet då? Joakim Lövgren står bakom två hästar och Jägersrotränaren har en spännande duo i <strong>Global Halo</strong> (e. Ready Cash) och <strong>Graffiti Brodda</strong> (e. Readly Express). De båda har vunnit två respektive tre starter och har vid sina varsina nederlag slutat tvåa.<br>Graffiti Brodda är också den i fältet som tagit hem den största segerchecken hittills, 187.500 kronor var vinsten i Breeders Crown-försöket på Jägersro värd.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/skarmavbild20260525kl.20.53.35-617x337.jpg" alt="" class="wp-image-854280"/><figcaption class="wp-element-caption">Global Halo</figcaption></figure>



<p>Så här säger Lövgren om sin duo i Axevallas banprogram till tävlingarna:<br>– Global Halo har visat sig vara en förståndig individ och det har så här långt inte varit minsta bekymmer med henne. Hon har bara förlorat en gång, men lustigt nog var det ändå hennes bästa lopp så här långt. Jag tror att hon kommer att öppna ganska bra bakom bilen. Senast i Mantorp körde jag bara på säkerhet från start.<br>– Graffiti Brodda har visat sig vara en stark avslutare och det kan nog komma väl till pass här, då hon har lottats till spår åtta bakom bilen. Formen är fin och hästen är gedigen på alla sätt och vis. Med tanke på spårlottningen är det ändå viss fördel Global Halo när det gäller mina två hästar.</p>



<p><strong>Tio senaste vinnarna av Guldstoet på Axevalla:</strong></p>



<ul class="wp-block-list">
<li>2016 <strong>Dream On Honey</strong> (e. Andover Andover) – Jim Oscarsson – 1.13,6a</li>



<li>2017 <strong>White Lightning</strong> (e. Maharajah) – Jörgen Westholm – 1.15,0a</li>



<li>2018 <strong>A Sweet Dance</strong> (e. Maharajah) – Johnny Takter (Helena Burman) – 1.14,4a</li>



<li>2019 <strong>Zolly</strong> (e. Zola Boko) – Mattias Djuse – 1.14,9a</li>



<li>2020 <strong>Hill’s Angel</strong> (e. Muscle Hill) – Björn Goop – 1.14,1a</li>



<li>2021 <strong>Islay Mist Sisu</strong> (e. Beer Summit) – Per Nordström – 1.13,9a</li>



<li>2022 <strong>Xerava C.D. </strong>(e. Uncle Lasse) – Mats E Djuse (Hans R Strömberg) 1.13,8a</li>



<li>2023 <strong>Loke Sancy Diamond</strong> (e. Raja Mirchi) – Örjan Kihlström (Roger Walmann) 1.14,2a</li>



<li>2024 <strong>S.G.Empress</strong> (e. Readly Express) – Örjan Kihlström (Roger Walmann) 1.14,5a</li>



<li>2025 <strong>Kobra Brick</strong> (e. Readly Express) – Mika Forss (Petrdi Salmela) 1.13,8a</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/kajsafrick2025-617x333.jpg" alt="" class="wp-image-749066"/><figcaption class="wp-element-caption">Kajsa Frick. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Förutom Guldstoet bjuds damloppet Hertiginnan av Västergötland Kronprinsessan Victorias lopp med 150.000 kronor till vinnaren på <strong>Axevalla</strong> (första start 13.45) i eftermiddag. Loppet har körts sedan 1993 och trion Charlotta B Svensson, Susanne H Osterling och Kajsa Frick har alla lagt beslag på vandringspriset efter tre segrar.</p>



<p>Efter tre utdelade vandringspris ändrade Axevalla statuterna för damloppet och från 2025 får vinnarna istället för att tävla om vandringspriset sitt namn på ett monument på publikplats på Axevalla.<br>Bland de tolv inbjudna kuskarna i årets upplaga har tre vunnit tidigare: Emilia Leo, Kajsa Frick och Linda Sedström.</p>



<p>Kajsa Frick har tillsammans med Susanne H Osterling flest segrar i kusksmatchen och hon sitter bakom ett starkt kort även i årets upplaga för att knipa sin sjätte seger. Det handlar om Robert Bergh-tränade <strong>Flight Sequence</strong> (e. Uncle Lasse) och tränarrapporten går i dur.<br>– Flight Sequence har varit kanonbra i år. Senast i Danmark var han jättefin, men åkte dit i sista steget mot en häst som kom väldigt långt ut i banan. Min häst blev helt enkelt för ensam där framme. Allt har varit bra efteråt och jag har siktat på just det här loppet. Han har fått ett perfekt startspår, säger Robert Bergh i Axevallas banprogram.</p>



<p>Totalt har 21 olika kvinnliga kuskar vunnit Kronprinsessan Victorias lopp och dessa har segrat två gånger eller fler:</p>



<ul class="wp-block-list">
<li><strong>Fem segrar: </strong>Kajsa Frick och Susanne H Osterling</li>



<li><strong>Tre segrar:</strong> Charlotta B Svensson</li>



<li><strong>Två segrar: </strong>Katarina Aurell och Elin Gustavsson</li>
</ul>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/07gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">3 Några av de tyska fyraåringarna som kommer delta i Derbyt i år får vi säkert se idag på Mariendorf-banan i Berlin. Där bjuds det på första benet i tyska Triple Crown.</p>



<p>Det handlar om Adbell-Toddington-Rennen (€20.000) och i den öppna klassen lär Paul Hagoorts <strong>Blizzard Diamant </strong>(e. Indigious), 1.10,0ak*/€91.851, bli storfavorit till segern. Han hade ett starkt fjolår med segrar i TCT Gold Cup, Åby Stora Treåringspris, Dreijährigen Kriterium och Tyskt Breeders Crown.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/09/202505191523blizzarddiamantz180525fkopie.jpg" alt="" class="wp-image-767616"/><figcaption class="wp-element-caption">Blizzard DIamant. Källa: Daglfing/München</figcaption></figure>



<p>Inför årsdebuten har europarekordhållaren två kval i kroppen på 1.13,1 respektive 1.12,4 över 2.100 meter med startbilens hjälp.</p>



<p>I stonas uppgörelse i Adbell-Toddington-Rennen (€10.000) ser det mer öppet ut på förhand, men <strong>Alma Mia</strong> (e. Maharajah) har hög potential – hon har vunnit fyra av sex starter – och är obesegrad felfri. Alma Mia är halvsyster med segermaskinen <strong>Aladin</strong> (e. Baltimore As), 1.11,2*/€139.049, som vunnit tio av 14 starter, men som fick se sig besegrad i det Tyska Derbyt ifjol av <strong>Summermusic’night S</strong>.</p>



<p>Hela tävlingsdagen går i Marilyn Monroes tecken. I år är det 100 år sedan hon föddes och besökarna uppmuntras att klä sig i 1950-talsstil för att delta i en Best-Dressed-tävling med attraktiva priser.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/berlinadbell-617x873.jpg" alt="" class="wp-image-859130"/><figcaption class="wp-element-caption">Mariendorf bjuder på topplopp idag, men ska också fira flimikonen Marilyn Monroe. </figcaption></figure>



<p><a href="https://www.hvtonline.de/bm/starter/20260607/" data-type="link" data-id="https://www.hvtonline.de/bm/starter/20260607/" target="_blank" rel="noreferrer noopener">Startlistorna hittar ni här.</a></p>



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



<p class="has-drop-cap">4 Igår hade <strong>Going For Gold Zaz </strong>(e. Scarlet Knight), 1.09,7ak*/3.934.317 kr, sin första vinnare. I Lindesberg debuterade Timo Nurmos-tränade <strong>Pure Gold Zaz</strong> (u. Patricia Zaz) och med Jorma Kontio i sulkyn blev det seger.</p>



<p>Duon övertog ledningen 1.450 meter före mål och sedan gick det treåriga stoet undan med fyra längder på 1.16,5/2.140 meter. Förstapriset uppgick till 45.000 kronor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260606kl.19.55.50-617x368.jpg" alt="" class="wp-image-859249"/><figcaption class="wp-element-caption">Pure Gold Zaz har gott om luft ner till sina konkurrenter.</figcaption></figure>



<p>Två avkommor har Going For Gold Zaz och båda föddes 2023. Pure Gold Zaz är hans första startande avkomma och hon är undan <strong>Patricia Zaz</strong> (e. Maharajah-Flamming Kick), 1.11,8ak/676.700 kr, som vann elva av 62 starter. Hon ingår i samma syskonskara som <strong>Whataboutyou Zaz </strong>(e. Maharajah), 1.12,7ak/494.135 kr, och <strong>Vincent Zaz </strong>(e. Orlando Vici), 1.12,4ak*/286.700 kr.</p>



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



<p class="has-drop-cap">5 På Krieau-banan i Wien är det genrep inför Österrikiskt Derby (€50.000) den 21 juni. Nio fyraåringar gör upp i Derby-Versuchsrennen (€10.000) över 2.600 meter.<br>Stoet<strong> Ivana Venus</strong> (e. Explosive Matter) har öppnat årets säsong starkt med fyra raka segrar, medan fältets vinstrikaste travare också är ett sto. <strong>Melody’s Fabula </strong>(e. Fabulous Wood) har tjänat 13.525 euro och i år har det blivit seger i Hambletonian Preis (€5.000) på 1.15,4a/2.100 meter.</p>



<p>Treåringarna tävlar om en ännu större prischeck i Karl Bürger Gedenkrennen (€15.000) över 1.600 meter. Calgary Games-sonen <strong>Calgary Muscles </strong>har inlett året med seger och ifjol blev det två vinster på tre starter för Gerhard Mayers häst.</p>



<p><a href="https://www.krieau.at/renntage/renntag/starterlisten?id=5441" data-type="link" data-id="https://www.krieau.at/renntage/renntag/starterlisten?id=5441" target="_blank" rel="noreferrer noopener">Startlistorna hittar ni här.</a></p>



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



<p class="has-drop-cap">6 Pennsylvania State Horse Racing Commission har meddelat en sträng dom mot travtränaren <strong>Owen C. Eiler Jr.</strong> efter att en av hans hästar testats positivt för den kraftfulla substansen Darbepoetin Alfa (DPO). Eiler dömdes till ett års avstängning och han ska betala 10.000 dollar i böter.</p>



<p>Överträdelsen skedde i samband med ett lopp i Chester den 14 november 2025. <strong>Stretch the Line</strong>, som tränas av Eiler, slutade trea och det efterföljande blodprover visade dock spår av DPO.</p>



<p>Darbepoetin Alfa är klassificerat som en Klass 1-drog med en så kallad A-påföljd, vilket representerar den högsta allvarlighetsgraden inom sporten. DPO är ett läkemedel som stimulerar produktionen av röda blodkroppar för att öka syreuppsättningen i blodet, vilket anses ge en betydande och otillbörlig prestationshöjning.</p>



<p>Och så blev travtränaren <strong>Allison MacDonald</strong> avstängd i sex månader efter ha hotat en ur Cumberland-banans domarkår med ett aggressivt och hotfullt språkbruk under den hätska ordväxlingen.</p>



<p>Incidenten inträffade den 22 maj i år efter ett kvallopp. Domaren blev stoppad av MacDonald, som var kraftigt missnöjd med domarnas beslut rörande hans häst, som under kvalet hade noterats för en galopp och därmed behövt kvala om.</p>



<p>Avstängningen trädde i kraft den 1 juni och sträcker sig till 27 november.</p>



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



<p class="has-drop-cap">7 Sundbyholmstravets måldomarnämnd hade en svettig kväll i fredags och delade ut hela 23 bestraffningar när banan bjöd på elva breddlopp. Rekord för en tävlingsdag? Ingen aning, men någon av Sulkysports läsare kanske kan ge ett svar? </p>



<h2 class="wp-block-heading">Här är hela listan över de som syndade:</h2>



<p><strong>Namn – Bötesbelopp – Förseelser</strong></p>



<ul class="wp-block-list">
<li><strong>Mats L Andersson </strong>– 1.500 kr – felaktigt bruk av körspö</li>



<li><strong>Lars D Carlson</strong> – 1.500 kr – övrig felaktig maning</li>



<li><strong>Kai P Jussila </strong>– 1.500 kr – övrig felaktig maning</li>



<li><strong>Alexander Kelm </strong>– 1.500 kr – övrig felaktig maning</li>



<li><strong>Mats Loberg</strong> – 1.500 kr – övrig felaktig maning</li>



<li><strong>Rolf Odén</strong> – 1.500 kr – övrig felaktig maning</li>



<li><strong>Amanda Sjökvist</strong> – 1.500 kr – felaktigt bruk av körspö</li>



<li><strong>Gro Helen Thonander</strong> – 1.500 kr – övrig felaktig maning</li>



<li><strong>Engla Tunmar </strong>– 1.500 kr – felaktigt bruk av körspö<br><em>– avstängd 19 juni-9 juli</em></li>



<li><strong>Emma Lindkvist </strong>– 1.000 kr – snäv körning grovt stört medtävlare<br><em>– avstängd 19 juni-2 juli</em></li>



<li><strong>Rikard S Jansson</strong> – 900 kr – dålig anslutning efter startbilen</li>



<li><strong>Göran Lihv </strong>– 900 kr – tagit fel spår i starten</li>



<li><strong>Lovisa Bergmark</strong> – 600 kr – tagit fel spår i starten</li>



<li><strong>Roland Jansson</strong> – 600 kr – snäv körning</li>



<li><strong>Göran Lihv </strong>– 600 kr – felaktig nedtagning av galopperande häst</li>



<li><strong>Alice Molin</strong> – 600 kr – stört medtävlare</li>



<li><strong>Sune L Nilsson</strong> – 600 kr – snäv körning</li>



<li><strong>Wim Paal </strong>– 600 kr – snäv körning</li>



<li><strong>Juhani Partanen</strong> – 600 kr – snäv körning</li>



<li><strong>Anna Isabella Karlsson</strong> – 300 kr – stört bilprovstart</li>



<li><strong>Victor Remneby</strong> – 300 kr – stört bilprovstart</li>



<li><strong>Lukas Berglind </strong>– avstängd 19-25 juni – halvspårskörning</li>



<li><strong>Victor Remneby</strong> – avstängd 19-25 juni – snäv körning</li>
</ul>

Fokustema
Sju nyheter vid sju
Läs senare
Vem gör susperstona sällskap?
Stjärnorna som vunnit både Guldstoet och Stochampionatet. Kajsa mot sjätte triumfen i dammatchen. Europarekordhållare i årsdebut. Svettig kväll för måldomarnämnd. Hotfullt språkbruk och dopingbrott gav långa avstängningar. Going For Gold Zaz första vinnare.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
