
<p class="has-drop-cap wp-block-paragraph">1 Finalerna i Solvallaseriens andra meeting för året är de sportsliga godbitarna på onsdagskvällen, där Solvalla (första start 18.15) och Åby (start 18.27) delar på uppmärksamheten.</p>



<p class="wp-block-paragraph">Hela nio försöksomgångar på onsdagarna har avgjorts på vägen till kvällens finaler med 150.000 kronor i varje. Nytt för i år är att ston har penningmässig fördel i alla klasser och av årets första tre finaler i mars vanns en av ett sto, Katja Melkko-tränade <strong>Relevant Stride</strong> (e. Maharajah). Av 36 finalister nu är prick hälften ston.<br>Kvällens största favorit är dock valack. Jörgen Westholm-tränade <strong>Natural Mine</strong> (e. Nuncio) har övertygat i två raka försökssegrar och inledde faktiskt 2024 med att vinna finalen i fjolårets sista meeting.</p>



<p class="wp-block-paragraph">Efter kvällen väntar ett kort tävlingsuppehåll och förberedelser för Elitloppshelgen för Solvalla, där nästa tävlingsdag är Elitloppsfredagen den 24 maj.</p>



<p class="wp-block-paragraph">Till Åby reser Färjestadstränaren Magnus Jakobsson med en riktig segermaskin. <strong>Always a Pleasure</strong> (e. Orlando Vici) har hunnit bli sex år, men bara hunnit med 15 starter så här långt. Nio av dem har slutat med seger, bland annat årsdebuten i Årjäng för tre veckor sedan där han ledde från start till mål. Nu är förutsättningarna annorlunda med bakspår, men Always a Pleasure har visat att han fungerar minst lika bra bakifrån. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/05/15v86.pdf">Här kan du ta del av dagens startlistor till tävlingarna på Solvalla och Åby.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-05-15_40_1">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-05-15_40_1">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Fuxvalacken <strong>Baron Gruff</strong> (född 1964 e. Jubla II) var en riktig segermaskin med 28 segrar på 47 starter, däribland storlopp som Oslo Grand Prix, Big Noon-Pokalen, C.Th. Ericssons Memorial, Silverhästen och Walter Lundbergs Memorial i regi Gösta Nordin.</p>



<p class="wp-block-paragraph">Men hans eftermäle handlar om dystrare saker, nämligen den sjukdom som han fick ge namn åt: ”Baron Gruff-sjukan”. Den är en tarmsjukdom med dödligt förlopp för många hästar eftersom den orsakar extrem uttorkning.<br>Det drabbades Baron Gruff av den 8 maj 1970, dagen efter att han i Walter Lundbergs Memorial på Solvalla tagit sin tionde raka seger. Baron Gruff dog senare på kvällen på veterinärhögskolan, berättas i Solvallas banprogram till kvällens tävlingar.</p>



<p class="wp-block-paragraph">En av hästarna som också drabbats var <strong>Järvsöfaks</strong>, som insjuknade hastigt sommaren 2004. Järvsöfaks, som var väldigt illa däran och nära döden, visade livsgnista och klarade livhanken.</p>



<p class="wp-block-paragraph">För femte året i rad körs på Solvalla ett minneslopp för Baron Gruff med 80.000 kronor till vinnaren. Stefan P Petterssons blixtsnabbe sprinter <strong>Comes With Age</strong> (e. Zola Boko) vann på 1.09,8ak på Bergsåker i augusti, men sedan dess är det nästan bara bokstäver i resultatraden. Nu kommer han från kvallopp och ställs inför en helt annan uppgift än i vanliga fall: han är ensam på tilläggsfållan.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Nästan 13 miljoner kronor extra ligger i kvällens åttarättspott på V86, sedan förra onsdagen blivit så favoritbetonad att utdelningen frös inne både för sex och sju rätt. Det var för övrigt elfte gången på 19 onsdagar under 2024 som det inte blev någon utdelning på sex rätt – och fjärde veckan i rad!</p>



<p class="wp-block-paragraph">Fem av 19 veckor har det varken blivit utdelning på sju eller sex rätt med den riktiga bottennoteringen den 17 april, där omgången som delades mellan Solvalla och Bjerke betalade 127 kronor (!) för åtta rätt.</p>



<p class="wp-block-paragraph">En gång i vinter har det blivit jackpot på åtta rätt.</p>



<p class="wp-block-paragraph">Hur ser det då ut inför kvällens omgång som delas mellan Solvalla och Åby? Sulkysports spelsstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Conrad Lugauer står över dagens tävlingar på Solvalla till förmån mot att tävla i Paris.</p>



<p class="wp-block-paragraph">På Vincennes (första start kl. 13.55) startar Lugauer en duo bland vilka <strong>Ferrari Sisu</strong> (e. Djali Boko) noteras som startade i tävlingsdagens clou, Prix du Gatinais (€90.000).</p>



<p class="wp-block-paragraph">Sju- till elvaåriga hästar gör upp om en segercheck på 40.500 euro över 2.850 meter voltstart och bland konkurrenterna syns även svenskfödde<strong> Bordeaux S.</strong> (e. Orlando Vici) som numera finns hos Erik Bondo.</p>



<p class="wp-block-paragraph">I Prix de Nice (€41.000) för femåriga ston som högst tjänat 57.000 euro tävlar därtill fjolårets Drottning Silvias Pokal-finalist <strong>Riverdale Z.</strong> (e. Maharajah) för Lugauer i konkurrens med Laurent Claude Abrivards svenskfödda sto<strong> Miss Jaja</strong> (e. Prodigious) över 2.100 meter autostart.</p>



<p class="wp-block-paragraph">I Prix d&#8217;Aire Sur l&#8217;Adour (€53.000) för sexåringar syns därtill Jörgen Westholms <strong>Ninepoints Lasse </strong>(e. Uncle Lasse) i strid med Christoffer Erikssons <strong>Django Silver</strong> (e. Django Riff) och Madelen Goetz <strong>Lucky Guy Boko</strong> (e. Broadway Hall).</p>



<p class="wp-block-paragraph">Tävlingsdagen avslutas med femåringsloppet Prix du Perreux (€90.000) för fjolårets derbyfinalist <strong>Coquaholy</strong> (e. Orlando Vici) gör sitt första framträdande för Erik Bondo.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-05-15/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Frode Hamre har varit en flitigt sedd gäst under Solvallas Elitloppshelg, men i år kommer han ner dra på antalet anmälda hästar rejält.</p>



<p class="wp-block-paragraph">Till Klass I-finalen har han kvalat in <strong>Wall of Moni </strong>(e. Walner) och till Bronsdivisionsfinalen <strong>Cool Trix</strong> (e. Trixton), men det tycks bara vara den förstnämnde som kommer att starta i STL-finalerna.<br>– Det är möjligt att jag anmäler Chalimar de Guez i Montéeliten också. Ifjol hade vi fem-sex hästar till start och de fick femte-sjättepris efter att travat 1.10 och 1.11-tider. De fick dåligt betalt och jag sade redan efter fjolårets lopp att &#8221;nästa år blir vi hemma&#8221;. Vi ska inte resa iväg bara för att det är kul och vara med, det är inte aktuellt, <a href="https://tgn.no/artikkel/derfor-sa-jeg-i-fjor-at-neste-ar-sa-blir-vi-hjemme/">förklarar Frode Hamre till TGN.no.</a> </p>



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



<p class="has-drop-cap wp-block-paragraph">6Den tvåfaldige STL-vinnaren <strong>Inspiration</strong> (e. Maharajah) 1.10,7ak/804.500 kr har bytt regi och finns numera hos Katja Melkko.</p>



<p class="wp-block-paragraph">I Joakim Lövgrens regi vann hästen dubbla Klass I-försök under sommaren år 2022 samt slutade tvåa i finalen samma period.</p>



<p class="wp-block-paragraph">Ifjol blev det sex starter, men ingen seger och nu blir det alltså Melkkos uppgift att försöka få tillbaka den av Stall Merrimac-ägda hingsten i bästa tänkbara slag efter att hästen inte tävlat sedan den 18 augusti.</p>



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



<p class="has-drop-cap wp-block-paragraph">7På Vermo (första start kl. 17.06) avgörs ikväll Femåringspokalen (€13.200) där halva dussinet deltagare strider om segerchecken på 6.000 euro.</p>



<p class="wp-block-paragraph">Bland dem finns fjolårets svenska derbyfinalist <strong>Monastery Boko</strong> (e. Chelsea Boko) som nu gör sin andra start i sitt nya hemland.<br>Jukka-Pekka Hukkanen tränar hästen som slutade sjua på Vermo för en månad sedan och som bland annat möter Irina Sarins <strong>Amazing Player</strong> (e. Quite Easy U.S.) som är inkvalad till Silverdivisionens final på Solvalla nästa lördag.</p>



<p class="wp-block-paragraph"><strong>Startlista Femåringspokalen</strong><br><em>2.120 meter autostart, förstapris: 6.000 euro</em></p>



<ol class="wp-block-list">
<li>Amazing Player – Jarmo Saarela</li>



<li>Corazon Combo – Pekka Korpi</li>



<li>Laxvikens Amiral – Tuomas Korvenoja</li>



<li>Monastery Boko – Tommi Kylliäinen</li>



<li>Callela Nelson – Hannu Torvinen</li>



<li>Crepe Match – Olli Koivunen</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Solvallaintressen på bred front
Om kvällens finaler av Solvallaserien, Conrad Lugauers dubbla chanser i Paris och svensk derbyhäst som ska luftas på Vermo går bland annat att läsa i veckans tredje morgonsvep.
