
<p class="has-drop-cap wp-block-paragraph">1 Alessandro Gocciadoro har ett enormt starkt facit på hemmaplan. Av sju Grupp I- och II-löpningar som avgjorts i Italien i år har han vunnit sex och det enda missade loppet – Gran Premio E.N.C.A.T. (€55.000) – fick han nöja sig med en andraplats med Free Time Jepson bakom Enrico Montagna-tränade <strong>Follia d’Esi</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/costa5-617x305.jpg" alt="" class="wp-image-834646"/><figcaption class="wp-element-caption">Magnus Djuse styrde Always Ek till vinst i Grupp I-loppet Gran Premio Costa Azzurra.<br>Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Samtliga fyra Grupp I-löpningar som körts har gått till Alessandro Gocciadoro och dessutom kan räkna in två Grupp II-segrar och fem Grupp III-vinster under 2026.</p>



<h2 class="wp-block-heading">Grupp I:</h2>



<p class="wp-block-paragraph"><strong>Namn – Lopp</strong></p>



<ul class="wp-block-list">
<li><strong>Always Ek </strong>– Gran Premio Costa Azzurra (€220.000)</li>



<li><strong>Giovaz </strong>– Gran Premio Derby dei 4 anni (€200.200)</li>



<li><strong>Guglielmo Jet </strong>– Gran Premio Derby dei 4 anni (€200.200)</li>



<li><strong>Dany Capar</strong> – Gran Premio Duomo (€165.000)</li>
</ul>



<h2 class="wp-block-heading">Grupp II:</h2>



<ul class="wp-block-list">
<li><strong>Giotto Ek </strong>– Gran Premio Firenze (€66.000)</li>



<li><strong>Il Trio Jet </strong>– Gran Premio Etruria (€66.000)</li>
</ul>



<h2 class="wp-block-heading">Grupp III:</h2>



<ul class="wp-block-list">
<li><strong>Ek del Ronco</strong> – Gran Premio della Vittoria (€35.200)</li>



<li><strong>Gandhi Mail </strong>– Gran Premio Andreani (€25.300)</li>



<li><strong>Global Agrement</strong> – Gran Premio Ponte Vecchio (€25.300)</li>



<li><strong>Ideal Turdance </strong>– Gran Premio Italia (€25.300)</li>



<li><strong>Goodbye Kiss</strong> – Gran Premio Trinacria (€25.300)</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 Hästägarsatsningen Kallsvenskan, med tio stall och 350 andelar i varje häst, drog igång den 1 februari. Ett stall, en häst, har verkligen rivstartat. Tre starter i vinter har slutat med två överlägsna segrar och ett tredjepris för Hanna Olofsson-tränade <strong>Hög Fara </strong>(e. Art Kjarvald).</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/02/hogfarahannaolofsson.jpg" alt="" class="wp-image-818258"/><figcaption class="wp-element-caption">Hög Fara och Hanna Olofsson. Foto Kallsvenskan &#038; Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Vid senaste triumfen sänkte hon rekordet till 1.34,8/2.180 meter. Ikväll hemma i <strong>Boden </strong>(första start 18.20) lär det behöva gå lite fortare om succén ska fortsätta omedelbart. Hög Far kommer ut i ett ”vanligt” lopp med äldre hästar, där alla utom en konkurrent gjort fler starter än treåriga Hög Fara.</p>



<p class="wp-block-paragraph">Hanna Olofsson har kört i varje start hittills, men då hon är bortrest på semester hoppar Mats E Djuse upp i vagnen bakom stoet som verkligen gjort avtryck hos sin tränare i Boden.</p>



<p class="wp-block-paragraph">– Hon har en sådan stjärnstatus. Man blir glad varje gång man kör henne. I värmning och hemma i träningen är hon som en shetlandsponny om hon inte har någon att träna med. Alltså så långsam! Direkt när det kommer till lopp är det fullt fokus och ordning och reda. Hon har hittills aldrig varit trött någon gång. Nu hoppas jag på en sänkning till 1.31–1.32?, säger Hanna Olofsson till Kanal 75.</p>



<p class="wp-block-paragraph">Av Kallsvenskans tio hästar har tre visat upp sig på tävlingsbanan så här långt. Olle Alséns <strong>Myllkärrs Wilma</strong> (e. Myllkärrs Sune) slutade tvåa i in debut i tisdags, medan Robert Skoglunds <strong>Mån Teddy </strong>(e. Dotterud Teddy) slutade sjua efter galopp i sin första start.</p>



<h2 class="wp-block-heading">Ställningen i Kallsvenskan</h2>



<p class="wp-block-paragraph"><strong>Häst – Tränare – Resultat – Prispengar – Poäng</strong></p>



<ol class="wp-block-list">
<li><strong>Hög Fara </strong>– Hanna Olofsson – 3 st: 2-0-1 – 53.500 kr – 293</li>



<li><strong>Myllkärrs Wilma </strong>– Olle Alsén – 1 st: 0-1-0 – 25.000 – 85</li>



<li><strong>Mån Teddy</strong> &#8211; Robert Skoglund – 1 st: 0-0-0 – 3.000 – 9</li>
</ol>



<p class="wp-block-paragraph">Övriga sju hästar har ännu inte debuterat.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 I början av juni ifjol slog André Eklundh-tränade <strong>Maverick K.W. </strong>(e. Cristal Money) till med den näst snabbaste debuttiden av en svenskfödd treåring genom tiderna när han travade 1.14,4a/2.140 meter på Färjestad. Bara blivande Kriterievinnaren <strong>Inti Boko </strong>(e. Chocolatier) hade varit snabbare när han debuterade på 1.14,2a/2.140 meter i Eskilstuna sju år tidigare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/andreeklundh-617x333.jpg" alt="" class="wp-image-462452"/><figcaption class="wp-element-caption">André Eklundh.  Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Maverick K.W. följde upp med ny seger i livets andra start ett par veckor senare. Han ströks från ett tilltänkt start på Axevalla i juli och hästen försvann för tävlingsbanorna.</p>



<p class="wp-block-paragraph">Idag på lunchbanan <strong>Mantorp</strong> (första start 12.20) är han tillbaka efter nästan tio månaders tävlingsuppehåll. Precis som i de två tidigare starterna handlar det om autostart och Maverick K.W. inleder från sjundespår bakom bilen i ett lopp där han står på kronan rätt inne propositionsmässigt med sina 75.000 kronor insprungna.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 Tidigare Jennifer Persson-tränade <strong>Pure Muscle</strong> (e. Muscle Hill-Allmar Surprise) vann storlopp på Kincsem Park i Budapest i helgen. Den sjuårige valacken tog hem Pulay Kornel Memorial med drygt 22.000 kronor i förstapris från spets. </p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/04/skarmavbild20260415kl.13.48.17.png" alt="" class="wp-image-838471"/><figcaption class="wp-element-caption">Pure Muscle vid storloppsvinsten i lördags i Budapest.</figcaption></figure>



<p class="wp-block-paragraph">Segertiden skrevs till 1.12,8a/1.900 meter och det var nytt löpningsrekord med en sekund. Andrea Fazekas satt i sulkyn och tränar Pure Muscle gör Horvath György. Favoriten El Valle Sagrado (e. Nuncio) slutade tvåa på 1.12,9. </p>



<p class="wp-block-paragraph">Fyra segrar och två andraplatser har det blivit åtta starter i Ungern och tidigare har han bland annat vunnit Tippmix Lovaregyleti Dij med cirka 33.000 kronor i förstapris och den triumfen togs på nyårsafton ifjol på Kincsem Park.</p>



<p class="wp-block-paragraph">Pure Muscle är undan <strong>Allmar Surprise </strong>(e. Angus Hall), 1.09,7ak*/4.449.577 kr, som har sin främsta avkomma i Fredrik Wallin-tränade <strong>Pure Count </strong>(e. Googoo Gaagaa), 1.10,6ak/2.481.500 kr, som slutade trea i Svenskt Travkriterium och korta E3 ifjol.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Dagarna efter att ha karriärens största seger som äldre i Moe Odins Äreslopp på Klosterskogen drabbades norske Kriterie- och Derbyvinnaren <strong>Gigant Tider </strong>(e. Norheim Svenn) av kolik och förra onsdagen transporterades hästen från Stavanger till Oslo och Bjerke djursjukhus för veterinärvård.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/05/giganttideratglive-617x333.jpg" alt="" class="wp-image-725127" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Fjolårets norske Derbyvinnare Gigant Tider och Kjetil Djöseland.</figcaption></figure>



<p class="wp-block-paragraph">I tisdags kunde en lättad tränare Kjetil Djöseland hämta hem sin stjärna.</p>



<p class="wp-block-paragraph">– Han är frisk och fin igen och lyckligtvis gick allt bra, säger Kjetil Djöseland till Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Den tilltänkta starten i Gaute Gudmestads Äreslopp på Forus med en plats i Elitkampen på Solvalla till vinnaren blir dock inte av.</p>



<p class="wp-block-paragraph">– Även om han är fin igen så är det klart att något som detta påverkar hästar, Vi får köra lite med honom här hemma och se hur han känns innan vi lägger upp några planer, säger Djöseland&#8230;</p>



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



<p class="has-drop-cap wp-block-paragraph">6 &#8230;tio hästar får plats i Elitkampen på Elitloppsdagen med en miljon kronor till vinnaren och det finns tre chanser att knipa en biljett på egen hand i kvallopp: Bollnäs Elitsprint den 8 maj, Gaute Gudmestads Äreslopp på Forus den 9 maj och Erkon Pokaali på Vermo den 10 maj.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/5tangenbork2-617x333.jpg" alt="" class="wp-image-588660"/><figcaption class="wp-element-caption">Tangen Bork. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Solvalla bjuder in en häst vardera från Sverige, Norge och Finland, medan resterande fyra platser tillsätts genom anmälan och högst startpoäng.</p>



<p class="wp-block-paragraph">Öystein Tjomsland-tränade <strong>Tangen Bork </strong>(e. Bork Odin) har vunnit loppet två år i rad, men har inte gjort årsdebut ännu efter att ha opererats i framknäna i november.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Första avkomman till <strong>M.T.Sollentuna </strong>(e. Quite Easy-M.T. Minnininnewah), 1.13,4am/598.400 kr, har sett dagens ljus på Broline International. Hon har fått ett svart stoföl efter Power och betäcks med Googoo Gaagaa i år.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/brolinefol2026stpowermtsolentuna-617x1074.jpg" alt="" class="wp-image-838439"/><figcaption class="wp-element-caption">M.T. Sollentuna med sin dotter efter Power. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">M.T. Sollentunas största seger togs som tvååring. Då vann hon ASVT Trottex Auktionslopp tillsammans med Kim Moberg och segern – värderad till 200.000 kronor – blev hennes främsta i karriären. </p>



<p class="wp-block-paragraph">För egen del är hon undan ostartade <strong>M.T. Minnininnewah </strong>(e. Credit Winner), vilken även lämnade duon <strong>M.T. Reed </strong>(e. S.J.’s Caviar), 1.12,0ak/618.979 kr, och <strong>M.T. Tatanka</strong> (e. Quite Easy), 1.13,9am/319.950 kr.</p>



<p class="wp-block-paragraph">Mödernet går tillbaka till championhingsten <strong>Quick Pays</strong> mor <strong>Spry Hanover</strong>, som också är mormor till Hambletonian Oaks-vinnaren <strong>Gleam </strong>($587.858), mormors mor till Derbyvinnaren <strong>Tsar d’Inverne </strong>(8.044.203 kr) och mormors mormor till Varenne (€6.038.411), <strong>Sevruga</strong> ($1.217.021), <strong>Selmer I.H. </strong>(5.314.530 kr) och <strong>Staro Miami </strong>($5.069.719 kr). </p>



<p class="wp-block-paragraph">Mormors mormors mor är hon till Kriterievinnaren <strong>Deimos Racing </strong>(€825.142) och mödernelinjen innehåller också världsrekordhållaren och Oaks-vinnaren <strong>Moder Teresa Sisu</strong>.</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
Gocciadoros starka facit
Snabb debutant gör comeback. Hög Fara i ”vanligt” lopp. Friskförklarad Kriterie- och Derbyvinnare. Storseger i Budapest på löpningsrekord. Nyfött på Broline.
Det är några av Sulkysports nyheter i morgonsvepet
Det är några av Sulkysports nyheter i morgonsvepet
