
<p class="has-drop-cap">1 Förra året vann Joakim Lövgren danska Derbyt med <strong>Kreadlys Lew</strong> (e. Readly Express). Att även femåringssäsongen kan bli rolig visade hingsten när han från ledningen plockade hem Kjell P Dahlströms Minne i Mantorp häromveckan.</p>



<p>Idag är hästen tillbaka på banan när Lövgren reser till Halmstad för sprinterloppet Yngve Larssons Memorial med 100.000 kronor till vinnaren. Där ställs Kreadlys Lew mot rutinerade snabbloppare som <strong>Dancer Brodde</strong> (e. Bold Eagle) och <strong>Four Guys Dream </strong>(e. Dream Vacation).</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/07/dancerbrodde.jpg" alt="" class="wp-image-739975"/><figcaption class="wp-element-caption">Dancer Brodde årsdebuterar idag. Foto Lars B Persson</figcaption></figure>



<p>– Kreadlys Lew gjorde det lopp han lovat mig i träning. Han kändes taggad, mjuk och fin och redo för årsdebut. Nu hoppas jag kunna hålla honom lite coolare hela sista varvet, han pep iväg lite onödigt fort 700 kvar senast. Det är en intelligent och klok häst, men nu råkade vi toucha två banmarkeringar och när det small till i hjulen pep han iväg. Jag tror inte det är någon fara att köra från start, men han har två katapulter på varsin sida om sig. Han är en rookie i sammanhanget, men är lovande och ingår att han måste stötas och blötas mot de bra snabblopparna, berättade Joakim Lövgren för ATG Live.</p>



<p>Yngve Larssons Memorial är en hyllning till en av banans grundare och har körts sedan 1979.</p>



<h2 class="wp-block-heading">Snabbaste vinnarna i Yngve Larssons Memorial:</h2>



<p><strong>År, vinnare (far) – Kusk (tränare) – Segertid</strong></p>



<ul class="wp-block-list">
<li>2023 <strong>Önas Prince</strong> (e. Chocolatier) – Per Nordström – 1.09,6a</li>



<li>2018 <strong>Day Or Night In</strong> (e. Muscle Hill) – Johan Untersteiner – 1.10,2a</li>



<li>2021 <strong>Harran Boko</strong> (e. Maharajah) – Conrad Lugauer 1.10,2a</li>



<li>2019 <strong>Ringostarr Treb</strong> (e. Classic Photo) – Wim Paal (Jerry Riordan) – 1.10,3a</li>



<li>2016 <strong>Tycoon Conway Hall </strong>(e. Conway Hall) – Steen Juul – 1.10,4a</li>



<li>2017 <strong>Delicious U.S.</strong> (e. Cantab Hall) – Örjan Kihlström (Daniel Redén) – 1.10,4a</li>



<li>2024 <strong>Night Brodde</strong> (e. Up And Quick) – Conrad Lugauer – 1.10,4a</li>
</ul>



<p>Det är jackpot på Grand Slam 75 idag med 2,8 miljoner kronor extra, fördelade enligt procentsatserna 40-20-40 i de tre vinstpoolerna.</p>



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



<p class="has-drop-cap">2 När det är årspremiär i <strong>Rättvik</strong> (första start 12.20) idag, så sker det utan banans framgångsrikaste tränare i många år. Leif Witasp, 75 år, har valt att lämna in proffslicensen efter en lång karriär i travets tjänst.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/leifwitasp-617x333.jpg" alt="" class="wp-image-160039"/><figcaption class="wp-element-caption">Leif Witasp. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>46 år som proffstränare blev det för Witasp, som har flera tunga segrar på meritlistan. 1989-1990 vann han Svenskt Trav-Oaks med <strong>Pershinette</strong> (e. Pershing) och <strong>Pink Lady</strong> (e. Shatter Way). 1991 tog han hem Europaderbyt, Grand Prix de l’U.E.T, på Vincennes med <strong>Market Leader</strong> (e. Snack Bar).</p>



<p>Andra topphästar som Leif plockat fram är <strong>Turbo Sund</strong>, <strong>Carl Otto</strong>, <strong>Perfect Sund</strong> och <strong>Cool Keeper</strong>.</p>



<p>Leif Witasp blev 2.000-klubbare både som tränare och kusk med 2.068 respektive 2.321 triumfer. 1984 tog han sitt första av 20 kuskchampionat hemma i Rättvik och dessutom blev han segerrikaste kusk på grannbanan Romme vid fyra tillfällen.</p>



<p>Dagens lopp då? Ja, i ett dubbelklasslopp möts två hästar som återkommit efter minst sagt långa uppehåll och gjort en start vardera. Frida Edin-tränade <strong>Van Gogh Z.</strong> (e. Love You) hade inte tävlat på tre år och åtta månader när han gjorde comeback i början av mars. Per Lindqvist tränar <strong>Likeaboss</strong> (e. Brad de Veluwe), som hade varit borta i tre år och en månad när han återkom till tävlingsovalen i början av mars.</p>



<p>Lopp i kroppen, är det minsta man kan säga inför dagens starter!</p>



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



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



<p class="has-drop-cap">3 Sulkysport har tidigare rapporterat om att dubbla Grupp I-vinnaren <strong>Joumba de Guez </strong>(e. Carat Williams), 1.11,7/€925.360, skulle lägga tävlingsskorna på hyllan. Förra året vann stoet både Prix de Cornulier (€700.000) och Prix de Paris (€400.000) på Vincennes för Eric Raffin respektive Jean-Michel Bazire, men har inte visat sig på tävlingsbanan efter den 5 april ifjol.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/joumbadeguezhu250127adamstromstalltz-617x857.jpg" alt="" class="wp-image-689803"/><figcaption class="wp-element-caption">Joumba de Guez. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Nu har ägaren bestämt sig för vem som blir stoets första partner i aveln. Joumba de Guez ska betäckas med <strong>Face Time Bourbon</strong>. </p>



<p>Den tidigare familjen Bazire-tränade travaren är en dotter till toppstoet och Prix de Paris-trean <strong>Quoumba de Guez</strong> (e. Urfist des Pres), 1.10,6/€1.186.790.</p>



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



<p class="has-drop-cap">4 I fredags skrevs travhistoria i Marseille. När <strong>Mogador Bleu</strong> skar mållinjen som etta innebar det inte bara en seger i mängden – det var nämligen avelshingsten <strong>Booster Winners</strong> 1000:e seger i Frankrike.</p>



<figure class="wp-block-image size-large"><img src="https://sulkysport.se/wp-content/uploads/2017/01/boosterwinnershtz-1024x555.jpg" alt="Booster Winner" class="wp-image-1207"/><figcaption class="wp-element-caption">Booster Winner. Foto: Simon Hagen/stalltz.se</figcaption></figure>



<p>Love You-sonen inledde sin karriär i avelsboxen 2015 efter en tävlingskarriär på absolut högsta nivå. Han tillhörde en av de mest talangfulla generationerna i fransk travhistoria och mätte sina krafter mot legendarer som <strong>Bold Eagle</strong>, <strong>Bird Parke</strong>r och <strong>Belina Josselyn</strong> – en karriär som kröntes med tre egna Grupp I-segrar.</p>



<p>Bland de 1.000 segrarna finns framgångar på alla nivåer, men några namn sticker ut extra mycket i Booster Winners meritlista som avelshingst. Den mest lysande stjärnan är utan tvekan <strong>Hooker Berry</strong>, som vann Prix d’Amérique 2023.</p>



<p>Men framgångarna slutar inte där. Han är även far till Grupp I-vinnarna <strong>Hastronaute</strong>, <strong>Kyt Kat </strong>och <strong>Jabalpur</strong>. Den sistnämnde innehar det absoluta banrekordet på Vincennes, tillika världsrekordet över 2.100 meter med 1.08,7a.</p>



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



<p class="has-drop-cap">5 Avelshingsten <strong>Air Power</strong> (e. Muscle Hill-Beyond Blue), 1.08,9/$378.941, har blivit pappa för första gången. På Silvåkra Stuteri nedkom Stall Garants <strong>Global Enterprise</strong> (e. Ready Cash), 1.13,6am/236.000 kr, med en hingst och det är också hennes första föl.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/img56981002-617x789.jpg" alt="" class="wp-image-831896"/><figcaption class="wp-element-caption">Global Enterprises första avkomma efter Air Power. Foto: privat</figcaption></figure>



<p>– Global Enterprise går till Ready Cash, berättar Kent Gullbjörk. </p>



<p>Tre segrar tog Global Enterprise på 15 starter – Bollnäs, Solvalla och Åby – innan hon sattes i avelsboxen. Hon är undan <strong>Global Midnight </strong>(e. Ganymede), 1.09,9ak/3.799.470 kr, som vann flera lopp i Frankrike – bland annat Prix de Plaisance på Enghien – men som också slutade trea i Sto-SM. </p>



<p>Av hennes avkommor har tre startat och förutom Global Enterprise handlar det om <strong>Global Braveheart</strong> (e. Ready Cash), 1.11,7ak/328.063 kr, och <strong>Global Graceful</strong> (e. S.J.’s Caviar), 1.12,6ak/247.046 kr.</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">6 En rad av duktiga italienskfödda treåringarna starar i Gran Premio Italia (€25.3000) i Bologna idag. Två lopp – ett för ston och ett för hingstar – avgörs på Arcoveggio-banan. för att göra upp i de historiska klassiska loppen för kullen.</p>



<p>I hingstarnas uppgörelse riktas blickarna främst mot <strong>Iambellesi Tq</strong> (e. El Ideal), vilkjen slutade tvåa i Grupp I-loppet Gran Premio Allevatori (€180.400) förra året. Han får dock tufft motstånd och <strong>Ideal Turdance</strong> (e. El Ideal) som kommer till start med fyra raka vinster.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/12/skarmavbild20251207kl.16.05.34-617x336.jpg" alt="" class="wp-image-800961"/><figcaption class="wp-element-caption">Irma Ferm och Marco Stefani vid segern i stoavdelningen i det italienska uppfödningsloppet, Gran Premio Allevatori.</figcaption></figure>



<p>I stonas avdelning är det också stjärntätt. <strong>Irma Ferm</strong> (e. Maharajah) tog hem stonas upplaga av Gran Premio Allevatori (€180.400). Utmanas gör hon i först hand av<strong> Ifinoe Degli Dei</strong> (e. The Bank), som tog hem finalen i Anact Stakes Plus+ (€200.200) förra året.</p>



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



<p><strong>Gran Premio Italia</strong> (€25.300) <br>Treåriga hingstar. <br><em>2.060 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Incanto Three</strong> (e. Maharajah) – Crescenzo Maione </li>



<li><strong>Iambellesi Tq</strong> (e. El Ideal) – Marco Stefano</li>



<li><strong>I Ioan Jet </strong>(e. Twister Bi) – Antonio di Nardo </li>



<li><strong>Ideal Turdance</strong> (e. El Ideal) – Alessandro Gocciadoro </li>



<li><strong>Italo Hp</strong> (e. Varenne) – Gennaro Amitrano</li>



<li> <strong>Indro LL</strong> (e. Royal Blessed) – Ioan Alin Gabor</li>



<li> <strong>Ideal Top</strong> (e. Tesoro Degli Dei) – Vincenzo Luongo </li>



<li><em>Iron Wise L (e. Maharajah) – struken</em></li>



<li><strong> Iceberg Bi</strong> (e. Readly Express) – Enrico Bellei</li>



<li><strong> Ifly Point</strong> (e. Greenshoe) – Andrea Farolfi</li>
</ol>



<p><strong>Gran Premio Italia</strong> (€25.300) <br>Treåriga ston.<br> <em>2.060 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Irenel Mail </strong>(e. Nad al Sheba) – Lorenzo Baldi</li>



<li><strong> Ice Killer Gar</strong> (e. Googoo Gaagaa) – Pietro Gubellini </li>



<li><strong>Irma Ferm </strong>(e. The Bank) – Marco Stefani </li>



<li><strong>In Scream Gio</strong> (e. Gimpanzee) – Tommaso Gambino</li>



<li> <strong>Ingrid Am</strong> (e. El Ideal) – Alessandro Gocciadoro</li>



<li> <strong>Isabelle Effe</strong> (e. Googoo Gaagaa) – Antonio Simioli</li>



<li> <strong>Iris Amg </strong>(e. Maharajah) – Roberto Ruvolo Ia</li>



<li><strong>lmaz Indal</strong> (e. Ze’Maria) – Rene’ Legati </li>



<li><strong>I Love America</strong> (e. Muscle Hill) – Antonio di Nardo</li>



<li><strong> Ifinoe Degli Dei</strong> (e. The Bank) – Vincenzo Luongo </li>
</ol>



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


<div class="factbox right minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Speed Cup Tour 2026:								</h3>
<div class="content">
<h2 class="wp-block-heading">Datum – Bana – Vinnare</h2>
<ul class="wp-block-list">
<li>18 mars – Saint-Galmier – <strong>Ineska </strong>(e Django Riff) – 1.10,8a/2.000 m</li>
</ul>
<p><strong>Återstående försök:</strong></p>
<ul class="wp-block-list">
<li>29 mars – Cavaillon</li>
<li>7 april – Cavaillon</li>
<li>23 maj – Beaumont-de-Lomagne</li>
<li>28 maj – Vichy</li>
<li>12 juni – Feurs</li>
<li>4 juli – Vichy (försök/final)</li>
</ul></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p class="has-drop-cap">7 Andra försöksomgången i Speed Cup Tour (€24.000) avgörs i dag i <strong>Cavaillon</strong> och första försöket vanns av <strong>Ineska</strong> (e. Django Riff) på 1.10,8a/2.100 meter. Idag är distansen 500 meter längre och loppet avgörs med voltstart. Favorit till segern är <strong>Jasmin du Vallon</strong> (e. Royal Dream) och Théo Briand och duon står med 25 meters tillägg.</p>



<p>Marie Norberg åker till Rambouillet för att köra <strong>Justess Viking</strong> (e. Ubriaco) och det sjuåriga stoet årsdebuterar i Prix de la Federation Idf-Hn (€24.000) över 2.800 meter. Förstapriset uppgår till 10.800 euro.</p>
