
<p class="has-drop-cap">1Jörgen Westholm-tränade <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) svarade för karriärens kanske bästa insats när han för två veckor sedan på Vincennes segrade i Prix Bettina (€59.000) på 1.10,4a/2.100 meter – efter en resa mestadels utan rygg.</p>



<p>Ikväll är han tillbaka på Vincennes (första start 18.23) med samma förutsättningar i Prix Jean Gabin (€68.000). Alexandre Abrivard sitter i sulkyn från spår sju bakom bilen. Ninepoints Lasse har vunnit åtta av 19 starter på fransk mark.<br>Ninepoints Lasse har vunnit Prix Bettina (€59.000), Prix de Sedan (€59.000), Prix de Marmagne (€43.000), Prix Ilster d’Espiens (€39.000), Prix de la Ville le Passage (€35.000), Prix Jacques Giboire (€32.000), Prix des Amis du Cheval (€30.000) och Prix Laura Flessel (€27.000) på fransk mark.</p>



<p>Ytterligare två svenska tränare har starthäst på kolstybben ikväll. Jörgen S Eriksson tar ut <strong>Carl Halbak</strong> (e. Orlando Vici) i Prix Dejanira (€56.000) för sju- och åttaåringar som tjänat upp till 156.000 euro med Matthieu Abrivard i vagnen. Duon vann tillsammans i Carl Halbaks senaste start på Vincennes för tre veckor sedan.</p>



<p>Markus B Svedberg ställer hoppet till <strong>Conrads Palle</strong> (e. Brillantissime) i sadelloppet Prix Klytaemnestre (€53.000), medan tysktränade, svenske Derbyfinalisten ifjol, <strong>Trogir</strong> (e. Love You), testas i Prix Ara (€41.000) tillsammans med Michael Nimczyk och möter Marie Norberg-tränade <strong>Nectar d’Occagnes</strong> (e. S.J.’s Caviar).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-05-16/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar ikväll.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/prixaristehemard2-617x435.jpg" alt="" class="wp-image-390509"/><figcaption class="wp-element-caption">Benjamin Rochard och Cash Bank Bigi vinner Prix Ariste Hemard. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap">2För fyra år sedan vann <strong>Cash Bank Bigi</strong> (e. The Bank) Treåriingseliten för ston på Solvallas Elitloppsdag. Mycket har hänt sedan dess för den fyrfaldiga miljonärskan som sedan treåringssäsongen tvlat mestadels på fransk mark och tränats av Sebastien Guarato, Fabrice Souloy och Erik Bondo.<br>Största segern kom som fyraåring i Prix Ariste Hemard (€120.000) på Vincennes, där hon speedade ner franska toppstoet Inmarosa (e. Amiral Sacha).</p>



<p>Efter att ha slutat femma i Prix de Plateau de Gravelle (€90.000) på Vincennes i mars bytte Cash Bank Bigi adress igen – till Daniel Wäjerstens stall. Ikväll i Bollnäs (första start 18.20) gör hon debut för sin nye tränare från tillägg i ett sex hästar litet fält, där åttafaldige miljonären <strong>Missle Hill</strong> (e. Muscle Hill) finns bland motståndarna.</p>



<p>Totalt har Cash Bank Bigi vunnit 13 lopp, varav åtta i Italien, fyra i Frankrike och så Treåringseliten i Sverige.</p>



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



<p class="has-drop-cap">3Bollnäs delar kvällens expresstrav med Kalmar (start 18.30), där det väntar försök i tre av banans löpningsserier med finaler senare under året – och en vårbonusserie.</p>



<p>Störst intresse röner stoserien med 15 damer fördelade på tre volter samlar poäng till finalen i Kalmar den 26 september med 150.000 kronor till vinnaren. Adrian Kolgjini-tränade <strong>Xia Lloyd</strong> (e. Raja Mirchi) drog in 930.000 kronor ifjol som fyraåring och med tredjeplatsen i Stosprintern som främsta merit. Hon var även finalist i både Drottning Silvias Pokal och Derbystoet, sedan hon vunnit försök till båda storloppen.<br>Nu har hon mjukstartat femåringssäsongen med två starter och en fjärdeplats som bäst inför kvällens uppgift från dubbla tillägg som loppets enda miljonärska.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/8xialloyd-617x333.jpg" alt="" class="wp-image-563960"/><figcaption class="wp-element-caption">Xia Lloyd och Dante Kolgini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Fyraåringsserien har premiär ikväll och finalen där avgörs den 28 november med 150.000 kronor i förstapris.</p>



<p>Montéhästarna och ryttarna gör upp i fjärde kvalet av fem till Kalmarsundsmontén, vars final rids i midsommar och lockar med 75.000 kronor till vinnaren. En av landets vassaste sadelhästar, Jesper Hedqvist-tränade <strong>Mcgarret</strong> (e. Weingartner), gör comeback efter 13 månaders frånvaro. Hästen har vunnit elva montélopp hittills.</p>



<p>En fjärde löpningsserie närmar sig final, E3:s Vårserie, där finalen avgörs på Romme den 30 maj med 100.000 kronor i vinnaren. Det elfte och sista försöket körs i Kalmar.</p>



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



<p class="has-drop-cap">4På tal om italienskor i Sverigedebut…som treåring kvalade Alessandro Gocciadoro-tränade stoet <strong>Easy di Girifalco</strong> (e. Maharajah) in till korta Breeders Course-finalen på Jägersro, men tvingades strykas för hälta. Nästan två år senare är hon tillbaka på svensk mark och på dagens lunchbana Lindesberg (första start 12.20) väntar första framträdandet.</p>



<p>Det nu femåriga stoet har gjort 34 starter (9-9-2) i Italien och kommer nu ut i ett lopp stängt vid 515.000 kronor, där hon dragit spår åtta bakom bilen tillsammans med Ulf Ohlsson.<br>Easy di Girifalco kommer närmast från seger i Neapel i mitten av mars. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/05/250516.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">5Elitloppet och Elitkampen i all ära – de snabbaste segertiderna under Elitloppshelgen kan skrivas in i speedrace för både varmblod och kallblod. Nio hästar per ras delas in i trehästarsfält och vinnaren går vidare till finalerna, där förstapriset är 100.000 kronor i varje.</p>



<p>Två hästar har kvalat in till loppet via uttagningarna i Gävle: <strong>Brenne Rön</strong> (e. Horgen Tore) och <strong>Jaguar Dream</strong> (e. Love You).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/jaguardream1-617x333.jpg" alt="" class="wp-image-169814"/><figcaption class="wp-element-caption">Jaguar Dream för sin förre tränare Claes Sjöström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Deltagare i speedrace på Solvalla:</strong></p>



<ul class="wp-block-list">
<li><strong>Kallblod: </strong>Alsaker Pumbaa, Brenne Rön, Dån Klara, Fakserling, Månremus, Pyckolina, Ros Borken, Snyggs Rubin och Torpa Nicklas.</li>



<li><strong>Varmblod: </strong>Bryssel, Chapuy, Cointreau, Frazze, Jaguar Dream, Krakas, Nugget Zon, Readly Lavec och Sabasi.</li>
</ul>



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



<p class="has-drop-cap">6Han var obesegrad i samtliga nio starter ifjol som treåring och bland vinsterna fanns både norska Kriteriet och Biris Uppfödningslopp. I årsdebuten i norska Kungapokalen på Bjerke för knappt tre veckor sedan inkasserade <strong>Gigant Tider</strong> (e. Norheim Svenn) karriärens första nederlag när Gigant Tider slutade tvåa från ledningen bakom Öystein Tjomsland-tränade <strong>Tangen Martin</strong> (e. Bork Odin).</p>



<p>Igår var Gigant Tider tillbaka på banan på Forus, där han ställdes mot äldre hästar. Därkörde Kjetil Djöseland till ledning efter ett drygt halvvarv, men valde att släppa till 20 meter bakom startande <strong>Idu Bork</strong> (e. Bork Odin). Där blev han kvar hela vägen när Idu Bork vann på 1.25,1/2.080 meter, medan Gigant Tider noterade 1.26,1/2.060 meter.<br>– Han var helpigg i mål och jag är jättenöjd med  hästen, sade Djöseland som närmast siktar på Sverigedebut i Prinsessan Madeleines Pokal i Bollnäs den 28 maj, enligt Trav- og Galopp-Nytt.</p>



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



<p class="has-drop-cap">7Ikväll är det dags för den finska varianten av Sprintermästaren, nämligen Kuopio Stakes över sprinterdistans med försök och final samma dag för fyraåringar. 29.000 euro är förstapriset i finalen ikväll, medan 6.500 euro väntar vinnarna i de två försöken.</p>



<p>Matti Nisonen är privattränare för Einari Vidgren Oy och har licens både i Finland och på Solvalla och på svensk mark har hans nyförvärv <strong>Lil Runner</strong> (e. So Perfect) tillbringat vintern på Julmyra. Lil Runner vann finska Kriteriet i höstas i Antti Teivainens regi och bytte efter säsongen till Nisonen.<br>Hästen gjorde bort sig med galopp i årsdebuten i Seinäjoki i mitten av aptil, men tar nu nya tag.</p>



<p>Värsta hotet finns i det andra försöket, Pekka Korpis <strong>Arctic Emerald</strong> (Express Duo), som vann just loppet i Seinäjoki från ledning på 1.14,4a/2.100 meter. Arctic Emerald har vunnit 16 av 30 starter och slutade tvåa i Kriteriet ifjol.</p>



<p><strong>Startlista Kuopio Stakes (€14.300)</strong> <strong>– försök 1</strong><br>1.609 meter autostart<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Heartbreaker (e. Flocki d’Aurcy) – Janne Räisänen (Arsi Skyttä)</li>



<li>Cereza Negro (e. Well Built) – Veijo Heiskari</li>



<li>Nacho Web (e. Like A Prayer) – Henri Bollström (Timo Korvenheimo)</li>



<li>Arctic Emerald (e. Express Duo) – Pekka Korpi</li>



<li>Mansester (e. Maharajah) – Esa Holopainen (Ilona Mäkinen)</li>



<li>Brandon Roden (e. Brad de Veluwe) – Riku Salminen</li>



<li>Neymar Web (e. Like A Prayer) – Santtu Raitala (Anne Kangas)</li>



<li>All Out You (e. All Laid Out) – Tommi Kylliäinen</li>



<li>BWT Johnny B.Goode (e. Harper Blue Chip) – Tuukka Varis (Mari Leinonen)</li>



<li>Xanthia Kemp (e. Trixton) – Hannu Torvinen (Hannu-Pekka Korpi)</li>
</ol>



<p><strong>Startlista Kuopio Stakes (€14.300)</strong> <strong>– försök </strong>2<br>1.609 meter autostart<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Daisy Garden (e. Maharajah) – Olli Koivunen (Markku Nieminen)</li>



<li>Lil Runner (e. So Perfect) – Santtu Raitala (Matti Nisonen)</li>



<li>The Lost Battalion (e. Flocki d’Aurcy) – Esa Holopainen (Heli Taipele)</li>



<li>Wik’s Noe Nee Pee (e. Enjoy Lavec) – Veijo Heskari</li>



<li>Levitating (e. Zola Boko) – Iikka Nurmonen (Jonny Länsimäki)</li>



<li>Madame de Vieki (e. Maharajah) – Tommi Kylliäinen (Hannu-Pekka Korpi)</li>



<li>Charlie Proud (e. Knows Nothing) – Jukka Torvinen (Christa Packalen)</li>



<li>Power Source (e. Propulsion) – Marko Heikari</li>



<li>Enrico Combo (e. Maharajah) – Pekka Korpi</li>



<li>BWT Jackpot (e. Maharajah) – Hannu Torvinen (Hannu-Pekka Korpi)</li>
</ol>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5LVV8xNi4wNS4yMDI1LnBkZg%3D%3D&#038;m=QV2h1a0DtBIJIKOkrEezNIuSFqo%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till alla lopp i Kuopio ikväll.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Lasses segertåg fortsätter i Paris?
Fyrfaldig miljonärska i Wäjersten-debut. Kvalfyllt i Kalmar. Vem är snabbast i speedrace? Kriterievinnare redo för första starten i Sverige. ”Solvallahäst” i finska Sprintermästaren.
Detta och mer bland morgonens nyheter.
Detta och mer bland morgonens nyheter.
