
<p class="has-drop-cap">1 Hon hade höga toppar under en stark treåringssäsong och var en av fyra kandidater till Årets Häst-titeln i svensk travsport 2025. Ända dit nådde inte Petri Salmela-tränade <strong>Kobra Brick</strong> (e. Readly Express), men med 60 procent av rösternas fick kretsen runt stoet kliva upp på scenen efter att ha utsetts till Årets treåring.</p>



<p>Av 13 starter ifjol slutade sex seger och de två största togs i långa E3-finalen och Breeders Crown. Lägg därtill två starter och lika många segrar som tvååring och Kobra Bricks facit hittills är 15 starter (8-3-1) och 3.727.250 kronor på kontot.</p>



<p>Den gemensamma nämnaren var Mika Forss i sulkyn, men när Kobra Brick kliver in i fyraåringssäsongen på <strong>Bergsåker</strong> (första start 18.20) ikväll är Forss ersatt av Ulf Ohlsson i jänkarvagnen efter ett beslut av ägargruppen och tränare Salmela.</p>



<p>Kobra Brick saknas i startlistorna till morgondagens försök till Drottning Silvias Pokal av den enkla anledningen att hon inte är anmäld till loppet. Dessutom saknas Kobra Brick i anmälningsrullorna till Derbystoet och säsongens två stora uppgifter blir Stochampionatet och Breeders Crown.</p>



<p>I kvällens spårtrappa ställs hon mot blott fyra motståndare över medeldistans med startbil.</p>



<h2 class="wp-block-heading">Vinstrikaste treåriga svenskfödda ston 2025:</h2>



<p><strong>Häst (far) – Resultat – Prispengar – Tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Kobra Brick </strong>(e. Readly Express) – 13 st: 6-3-1 – 3.677.250 kr – Petri Salmela</li>



<li><strong>Bonsse Garde </strong>(e. Makethemark) – 13 st: 5-3-2 – 3.563.250 kr – Fredrik Wallin</li>



<li><strong>Moder Teresa Sisu</strong> (e. Walner) –   7 st: 4-3-0 – 2.647.500 kr – Timo Nurmos</li>



<li><strong>Global Got It All </strong>(e. Walner) – 12 st: 4-1-1 – 1.941.500 kr – Fredrik Wallin</li>



<li><strong>Xanthis Kylie </strong>(e. Tactical Landing) – 13 st: 2-2-4 – 1.378.000 kr – Fredrik Wallin</li>
</ol>



<p>Statistiken gäller ston i svensk träning.</p>



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



<p class="has-drop-cap">2 Det är generellt små fält vid <strong>Bergsåkers</strong> tävlingar. Ytterligare två lopp ser endast fem deltagare och ett lopp har sex hästar. I en spårtrappa för treåringar kommer fyra av fem anmälda hästar från Daniel Wäjerstens stall, vilket får till följd att ATG ställer in spelet i loppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/kingenjabcjjm260318adamstromstalltz-617x398.jpg" alt="" class="wp-image-828912"/><figcaption class="wp-element-caption">Kingen J.A.B. och Carl Johan Jepson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Wäjerstens kvartett får dock kämpa rejält för att ta hem segern – motståndaren är Robert Dunders talang <strong>Kingen J.A.B.</strong> (e. Nuncio), som vunnit fyra av sex starter hittills i karriären.</p>



<p>Det finns fler segervana fyrbenta hästar till start. Som Jan-Olov Persson-tränade duon <strong>Palmesus N.O. </strong>(e. Nordsjö Odin) och <strong>Stjärnmode</strong> (e. B.W.Modde) med tre raka vinster i bagaget. Den förstnämnde ska försöka plocka in 20 meter på fjolårets Derbykvalvinnare <strong>Bazoo Can</strong> (e. Ängsborken), som vunnit tre lopp och inte varit sämre än tvåa på årets fem starter.</p>



<p>På varmblodssidan fortsätter fjolårets segerrikaste häst på svensk mark, Wäjersten-tränade <strong>Shogun R.R.</strong> (e. Realdy Express), att plocka segrar. Ifjol blev det tio triumfer och i år har han hunnit med tre på fyra försök.</p>



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



<p class="has-drop-cap">3 Efter en mjukstart med breddlopp vid årspremiären häromveckan blir det ordinarie propositioner och prispengar när <strong>Visby</strong> (första start 12.20) är torsdagens lunchbana.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2021/09/claessjostrom2.jpg" alt="" class="wp-image-219579"/><figcaption class="wp-element-caption">Claes Sjöström blev champion på Visbytravvet för 13:e gången förra året. Idag göra han sitt första besök 2026. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Då blir det också årets första besök för banans kuskchampion de tio senaste åren (13 titlar totalt) Claes Sjöström, som dessutom tar med fyra hästar från egna stallet.</p>



<p>En av dem är USA-födda miljonärskan <strong>Lavender </strong>(e. Walner), som laddat om efter en tyngre fyraåringssäsong. Nu kliver hon ut i snabbloppet, där den mest meriterade motståndaren är forne Uppfödningsloppvinnaren <strong>Belker</strong> (e. Scarlet Knight).</p>



<p><strong>Skellefteå</strong> (första start 17.45) kompletterar utbudet som kvällens saxbana och hemmaamatören Hugo Lundgren har fått härlig snurr på sitt kallblod <strong>Mälarstens Sagari</strong> (e. Mino). Två segrar på fjolårets tre sista starter har följts upp av tre raka triumfer under 2026. Den sviten kan förlängas i en spårtrappa idag.</p>



<p>En annan hemmaamatör som vet hur man vinner lopp är Per Edström, som plockar ut <strong>Done Deal</strong> (e. Maharajah) med sju segrar på elva starter hittills i karriären i ett dubbelklasslopp.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/04/260423.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/04/260423.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 <strong>Kobayashi</strong> (e. Face Time Bourbon), 1.10,1m*/€477.880, kommer till Harper Hanovers lopp och i senaste starten – Prix Aletheia (€90.000) – hade han lekstuga med topptravaren Karambar på Vincennes. Innan dess slutade han tvåa bakom Ino du Lupin i Prix du Bois Vincennes.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/prixaleithea1-617x321.jpg" alt="" class="wp-image-839714"/><figcaption class="wp-element-caption">Kobayashi vid seger på Vincennes.<br>Foto: Gerard Forni</figcaption></figure>



<p>Tidigare i år har den Mathieu Mottier-tränade sexårige hingste också vunnit Grupp I-löpningen Prix de Centaures (€240.000) under sadel på löpningsrekordet 1.10,1/2.200 meter.</p>



<p>Kobayashi började karriären hos Tomas Malmqvist och under hans flagg blev det fyra segrar och däribland två på Vincennes som treåring i Prix Arethusa (€62.000) och Prix Dangeul (€52.000).</p>



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



<p class="has-drop-cap">5 Toppkusken John F. ”Sonny” Patterson Jr. har avlidit vid 81 års ålder. Pattersons karriär sträckte sig över fem decennier och är för den svenska publiken mest känd för sina stora segrar med Per Erikssons <strong>Lookout Victory</strong>. Tillsammans vann duon bland annat dubbla Breeders Crown, Hambletonian Oaks och World Trotting Derby Filly.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/lookoutvictoryjp950805-617x309.jpg" alt="" class="wp-image-841541"/><figcaption class="wp-element-caption">Lookout Victory och John Patterson Jr. Foto: stalltz.se</figcaption></figure>



<p>En annan topphäst som selades ut från Per Erikssons stall var <strong>Giant Chill</strong> och honom guidade Patterson Jr. till segrar i Breeders Crown, Peter Haughton Memorial och Zweig Memorial. Vinst blev det också med Per Erikssons <strong>Giant Force </strong>i Yonkers International Trot.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/unknown-617x321.jpeg" alt="" class="wp-image-841542"/><figcaption class="wp-element-caption">Giant Chill vid segern i Peter Haughton Memorial för ”Sonny”. Foto: stalltz.se</figcaption></figure>



<p>Hans första seger kom 1964 i Du Quoin och sista loppet körde John F. ”Sonny” Patterson Jr. 2002. Då hade han vunnit 2.989 lopp och kört in närmare 33 miljoner dollar.</p>



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



<p class="has-drop-cap">6 <strong>Morningstar</strong> (e. Cantab Hall-Passionate Glide), 1.11,1/$69.757, har fått ett sto efter Walner på Snogarps Gård. Hon har sin främsta avkomma i Daniel Redén-tränade <strong>Bright Star </strong>(e. Muscle Hill), 1.09,1ak/2.244.666 kr, och <strong>Starita</strong> (e. Trixton), 1.09,1/$209.509. Nämnas kan också treåriga <strong>Nightcap Mearas</strong> (e. Walner), 1.11,2/$17.725, vilken inlett året med en andra och tredjeplats.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/morningstar-617x484.jpg" alt="" class="wp-image-841528"/><figcaption class="wp-element-caption">Morningstar med sin dotter efter Walner. Foto: privat</figcaption></figure>



<p>Morningstar är i sin tur undan storstjärnan <strong>Passionate Glide</strong> (e. Yankee Glide-Miss Marita), 1.09,8*/$2.060.447, vilken tränades av Jimmy Takter och vann bland annat Breeders Crown, Goldsmith Maid, Hambletonian Oaks och stoavdelningen i Kentucky Futurity.</p>



<p>Nämnas kan också att Passionate Glide är halvsyster med Hambletonian Oaks-ettan <strong>Marita’s Victory </strong>($666.731), avelshingstarna <strong>Mr Vic </strong>($318.942) och <strong>Mr Cantab </strong>($139.419), varav den sistnämnde är far till världens snabbaste travare genom tiderna – <strong>Homicide Hunter,</strong> 1.07,6*/$1.768.280.</p>



<p>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>



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



<p class="has-drop-cap">7 Till <strong>Reims</strong> (första start kl. 11.51) åker Jarmo Niskanen med <strong>Monogame</strong> (e. Uniclove) och startar i Prix Atlantic (€18.000) över 2.500 meter autostart. Joan Melis Macias sitter i sulkyn och förstapriset uppgår till 8.100 euro.</p>



<p>I årsdebuten i Amiens slutade den fyraårige hingsten fyra i Prix Jean Lapierre i Amiens. Ifjol vann Monogame ett lopp på fem starter och triumfen kom i debuten – Prix du Pays de Bray (€12.000) – i Gournay-en-Bray.</p>



<p>En tredje- och femteplats blev det för Jörgen Westholms duo Natural Mine (e. Nuncio) och Cameron (e. Maharajah) i Grand National des Jockeys (€34.000) i Chateaubriant igår.</p>



<p>Duon var helt utan chans mot 34-oddsaren <strong>Hold Up des Ventes</strong> (e. Very Pleasant-Tornade d’Aumont) och Gaëtan Gilard. Tränar gör Martial Gilard och segertiden skrevs till 1.12.9/3.025 meter.</p>



<p>Tredjeplatsen var värd 4.760 euro för Natural Mines ägare Norchri AB, medan femtepriset för Camerons ägare Jas Fastigheter AB uppgick 1.700 euro.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Årets Treåring i årsdebut
Kuskbyte på Kobra Brick. Toppkusk ur tiden. Champion tillbaka. Nyfött på Snogarps Gård. Grupp I-vinnare till Harper Hanovers lopp.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
