
<p class="has-drop-cap wp-block-paragraph">1Är kampen om att ta ledningen i nya E-lioppsserien med två biljetter till Elitloppet i potten över redan efter 150 meter? Räkna i alla fall med att det blir fullt blås från start i dagens guldfinal på Solvalla (första start 14.35) – C.Th.Ericssons Memorial med en halv miljon kronor till vinnaren.</p>



<p class="wp-block-paragraph">Vi tar grundförutsättningarna först för de hetaste spetskandidaterna.</p>



<ul class="wp-block-list">
<li><strong>Karat River</strong> (e. Muscle Hill) – spår 1.</li>



<li><strong>A Fair Day</strong> (e. Maharajah) – spår 2.</li>



<li><strong>Mellby Jinx</strong> (e. Ready Cash) – spår 5.</li>
</ul>



<p class="wp-block-paragraph">Snabbaste öppningen har uppmätts av <strong>Stens Rubin</strong>, enligt statistik från Kanal75, som travade 0.59,9 första 150 meterna under Unionstravet på Färjestad i september ifjol. Då hade han innerspår bakom bilen. Nu är läget betydligt längre ut bakom vingen, men från just sjättespår öppnade han på 1.00,3 på Solvalla i guldfinalen för prick ett år sedan.</p>



<p class="wp-block-paragraph">När det gäller favoritduon <strong>A Fair Day</strong> och <strong>Mellby Jinx</strong> är A Fair Day kvickast med 1.00,6 från spår fem på Åby i maj ifjol. Från invändiga spår (ett och två) är snabbaste öppningen 1.03,6 i Kalmar hösten 2024. Mellby Jinx har som snabbast inlett på 1.01,5 från spår fyra, i Sundsvall Open Trot på Bergsåker 2024. På Solvalla i UET Elite Circuit-finalen i höstas hade han spår fem bakom bilen och drog iväg efter 1.01,7.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/elisabethalmheden1-617x333.jpg" alt="" class="wp-image-772799"/><figcaption class="wp-element-caption">Elisabeth Almheden. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">För kretsen runt A Fair Day är taktiken given!<br>– Han fick pusta en vecka och sedan har vi tränat på enligt plan. Han är uppkollad och det var utan anmärkning så det var tacksamt. I måndags tränades han inne på Kalmartravet, då vi avslutade med fem intervaller i sanden. Allt såg bara bra ut och vi är nöjda inför lördagen. Spåret blev dessutom helt perfekt och det är tacksamt att vi har snabbe Mellby Jinx på vår utsida. Spåren betyder mycket och Oscar får gasa. Det har han inget emot och spets vore fint. Det blir barfota runt om, säger Elisabeth Almheden till Kanal75.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/03/28v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/9wiseguy1-617x333.jpg" alt="" class="wp-image-723156"/><figcaption class="wp-element-caption">Wise Guy och Per Nordström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Ifjol som treåring satte han världsrekord och vann dubbla Grupp I-lopp. Idag på Solvalla debuterar <strong>Wise Guy</strong> (e. Face Time Bourbon), 1.11,0am*/3.871.250 kr, i Daniel Redéns regi när han kommer ut i en av fyra avdelningar i Margaretas Tidiga Unghästserie. Det blir första starten sedan Kriterierevanschen på Solvalla i mitten av november, då Wise Guy efter loppet stannade kvar i räjongen och gick i tärning till Redén.<br>– Det är lite svårbedömt, han myglar lite i träning och det är svårt att få grepp om honom på sandbanan. Det blir mycket nytt för oss att lära känna honom på tävlingar. Han kommer att behöva loppet, det är så vi har lagt upp det. Det är lite för tidigt, men det finns inte så mycket lopp att välja på och han ska förhoppningsvis ut i Kungapokalskvalen. Han har hög kapacitet och säkerligen har han lurat oss mycket i träning, sade Daniel Redén till V65 Direkt.</p>



<p class="wp-block-paragraph">Face Time Bourbon-sonen tävlade framgångsrikt för Per Nordström och förutom världsrekordet på 1.11,0a/2.140 meter på Solvalla vann Wise Guy Solvalla Hästägarförenings Tvååringspris, Vinterfavoriten, Breeders Course/Treåringseliten och finalen i långa E3.</p>



<p class="wp-block-paragraph"><strong>Första omgången av Margareta-serien avgjordes i början av februari och här är vinnarna:</strong><br><em>Treåringar</em></p>



<ul class="wp-block-list">
<li><strong>Nanda Devi Cut</strong> (h e. Maharajah) – Magnus A Djuse (Mattias Djuse)</li>



<li><strong>Icy Conditions</strong> (s e. Calgary Games) – Claes Sjöström</li>
</ul>



<p class="wp-block-paragraph"><em>Fyraåringar</em></p>



<ul class="wp-block-list">
<li><strong>Mister Smartface</strong> (v e. Booster Winner) – Adrian Kolgjini</li>



<li><strong>Facetime Queen</strong> (s e. Face Time Bourbon) – Magnus A Djuse (Timo Nurmos)</li>
</ul>



<p class="wp-block-paragraph">Avvinnarna finns tre med på Solvalla idag, båda treåringsettorna Nanda Devi Cut och Icy Conditions, samt Facetime Queen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/sjostroms-lyft/" target="_blank" rel="noreferrer noopener">Läs mer om Claes Sjöström i fredagsintervjun här!</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Det bjuds alltså hög sportslig klass på Solvalla i eftermiddag och detta kryddas ytterligare på spelsidan. Nästan 20 miljoner kronor extra ligger i åttarättspotten när det är jackpot på V85. Totalt väntas högsta vinstpoolen innehålla 44 miljoner kronor.</p>



<p class="wp-block-paragraph">Sulkysports expertpanel har plockat fram sina bästa spikförslag och skrällbud i omgången. En häst som får förtroendet som spik är tredjehandsfavoriten <strong>Kipketer Mearas</strong> (e. S.J.’s Caviar) i silverdivisionen (V85-3) – och Fredrik Persson på Simsalabim får medhåll från tränaren Ulf Stenströmer.<br>– Kipketer Mearas möter bra hästar, men han är bra också och jag blir inte alls förvånad om han vinner. Han ger alltid allt och fortsätter att utvecklas. Jag är ganska säker på att Kipketer Mearas kommer att kliva upp i högsta klassen i år om han får vara frisk och fräsch. Jag har varit mycket nöjd med de två starterna han gjort i år och allt talar för att han kommer att göra ett mycket bra lopp igen. Kipketer Mearas är snabb från start, men det är det fler som är, säger Ulf Stenströmer till Kanal75.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-jackpot-s-28-mars/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Solvallas V85-omgång.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/simsalabim/V85_2026-03-28_5_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-03-28_5_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/spelpoolen/V85_2026-03-28_5_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Tävlingskarriären är över för toppstammade fyraåriga stoet <strong>Mumin Mearas</strong> (e. Walner-El Catwalk), 1.12,0ak/429.000 kr. Anledningen är att hon drabbats av hjärtmuskelinflammation och hästen är belagd med permanent startförbud. Ikväll säljs hon som fölsto på Travera.<br>Mumin Mearas tävlade för Björn Goop som treåring och gjorde tio starter (2-1-0). Största segern kom i ett Breeders Crown-försök i Årjäng i maj förra året. Hon kvalade även in till BC-finalen för treåriga ston (oplacerad) i höstas, vilken blev karriärens sista start.</p>



<p class="wp-block-paragraph">Hennes mamma är finskfödda <strong>El Catwalk</strong> (e. Classic Photo), 1.12,0ak/3.730.869 kr, som var en topphäst på tävlingsbanan med 27 segrar på 58 starter. De största triumferna kom i finska Stokriteriet och Breeders Crown. <br>Mödernet går tillbaka till fenomenala fölstoet <strong>Lady Ann Reed</strong>, som är mormors mormor till El Catwalk.</p>



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



<p class="has-drop-cap wp-block-paragraph">5En svensktränad häst dyker upp på fransk mark idag. Till Nancy (första start 11.25) sänder Jarmo Niskanen sexåriga stoet <strong>Katitzi</strong> (e. Earl Simon), som gör första starten sedan i december. Hon har vunnit fem av 21 starter hittills i karriären när hon nu kommer ut i Prix Jacques Gruber (€19.500).<br>Grunddistansen är 2.600 meter och Katitzi, som är rikast i fältet, startar från 25 meters tillägg. Joan Melis Macias sitter i vagnen.</p>



<p class="wp-block-paragraph">Jarmo Niskanen har bara gjort tre starter som tränare hittills i år. Han väntar på första segern, men har ännu inte missat prispallen.</p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/03/howardlandmal-617x277.jpg" alt="" class="wp-image-831854" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Homard Land.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Några svenskfödda travare provade lyckan på Vincennes igår och bäst gick det för Erik Bondo-tränade <strong>Pure Steel</strong> (e. Bird Parker) med en andraplats från dödens i Prix Eos (€53.000) och den insatsen värderades till 13.250 euro. </p>



<p class="wp-block-paragraph">Från andra ytter attackerade <strong>Kheo Vivanciere</strong> (e. Tucson-Sidonie de Joe) 400 kvar och när storfavoriten El Dorado Bar galopperade i täten 200 meter före mål blev den förstnämnde ensam på plan. <br>Vinnartiden för Kheo Vivanciere och Mathieu Mottier skrevs till 1.13,9/2.850 meter. Pure Steel noterade 1.14,2 som tvåa, fyra slutade Christoffer Erikssons <strong>Jubii Vang</strong> (e. Maharajah) på 1.14,4 och sexa i mål var Eric Martinssons <strong>Fusion Eagra</strong> (e. Django Riff) på 1.14,5. </p>



<p class="wp-block-paragraph">Jörgen Westholms <strong>Ninepoints Lasse</strong> galopperade bort sig 1.800 kvar i Prix Amalthea (€68.000) och när favoriten <strong>Homard Land</strong> (e. Tresor Wic-Suzy des Vals) gick till spets 1.950 meter före mål var förstås mycket vunnet. Från ledarryggen försökte <strong>Jerzinho Sport</strong> utmana, men Homard Land höll säkert undan till seger för Eric Raffin på 1.12,1/2.700 meter. För Homard Land var det tredje raka segern.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/alliwishfol-617x819.jpg" alt="" class="wp-image-831856"/><figcaption class="wp-element-caption">Här är All I Wishs hingstföl med Readly Express som pappa.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7På Silvåkra Gård har <strong>All I Wish</strong> (e. Bar Hopping) fått en hingst efter Readly Express och det är stoets första avkomma. Lina Alm äger och kan berätta att Gimpanzee blir nästa partner för det ostartade stoet. </p>



<p class="wp-block-paragraph">All I Wish är undan <strong>Ms Stone</strong> (e. Enjoy Lavec), 1.13,9/$6.765, vilken har sin främsta avkomma i USA-födda <strong>Stardust Memories</strong> (e. Cantab Hall), 1.11,0/$338.596, medan <strong>Rushmore Face</strong> (e. Raja Mirchi), 1.09,5ak*/1.552.836 kr, är bäst av hennes svenskfödda. </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.</p>



<p class="wp-block-paragraph"><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Först ut – först till slut?
Spetsstriden avgör i Elitloppskampen. Redén om världsrekordhållarens årsdebut. Experten får medhåll. BC-finalist ifjol – permanent startförbud nu. Svenskfödd tvåa på Vincennes.
Detta och mer bland lördagens nyheter.
Detta och mer bland lördagens nyheter.
