
<p class="has-drop-cap wp-block-paragraph">Det är en vidöppen och svårtippad V75-omgång som vi fått arbeta med den här veckan när STL Champions står på programmet.<br>Med sju femtonhästarsfält är det upplagt för hög utdelning och vi tycker att flera av loppen är väldigt jämna.<br>Bland annat heltäcker vi den andra avdelningen och har placerats samtliga hästar i B-gruppen. Något vi aldrig kan påminna oss om att ha gjort tidigare i ett så stort fält.</p>



<p class="wp-block-paragraph">Spikarna hämtar vi i mellanavdelningarna. <strong>Dynamite Sensation</strong> (V75-4) såg tankad ut över målgången i senaste starten och ska ha god chans att forceras till tät från tillägg.<br><strong>Beauty Smart Face</strong> (V75-5) kan mycket väl visa sig vara en häst för Stochampionatet i sommar och vi tror hon rundar hela gänget i lag med skicklige Gustav Johansson i STL Lärlingschampion.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/02/11v75.pdf" target="_blank">Här kan du ta del av startlistor till tävlingarna på Åby.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-02-11_6_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-02-11_6_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-02-11_6_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – STL Champions &#8211; Stayerlopp, 3.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Conch On Inn </strong>tycker vi är en rolig tipsetta i ett vidöppet lopp. Han såg inte trött ut när galoppen kom 300 meter före mål i rygg på segermaskinen Vice Versa Diamant vid sin senaste stayerstart i november och har fortsatt verkat formstark hela vintern. Att ta dödens under slutvarvet på Borups Victory senast i Östersund blev honom övermäktigt, men han slog aldrig av på takten helt och var bara nos från tredjeplatsen. Hästen öppnade jättebra från springspår på tillägg på Romme den 8 november i lag med just Ulf Ohlsson och vi påminner därtill att hästen var tvåa bakom Kentucky River i ett Klass II-försök över lång distans i Örebro i våras så han står distansen.</li>



<li><strong>Flirting Diamond</strong> fick göra jobb under såväl de inledande som avslutande 700 meterna på Solvalla och föll med flaggan i topp som nosslagen av Xerxes Millpond. Han revanscherade sig på Åby där han kom ner i rygg på Lovely Lasse ut på sista bortre långsidan och krigade sig förbi till säker seger via 1.13,5 sista varvet. Stefan Persson var uppsatt som förstaval på tre hästar (även Demir K.M.E. samt Papa Crowe) i det här loppet och har valt Emma E Johanssons häst vilket stärker upp hur nöjd han var med bekantskapen vid senaste segerloppet.</li>



<li><strong>Kirby Starlake</strong> trodde vi hade för svag segeraptit för att duga på svensk mark, men han motbevisade oss verkligen vid förra veckans segerlopp. Efter spets och släpp lyckades Rick Ebbinge skifta spår på sista bortre långsidan när ledaren slocknade och när sexåringen fick fritt in mot upploppet small det bara till. Hästen avslutade så pass fort som 1.11,5 sista 700 meterna och då han var före den färska Bronsdivisionstrean Exclusive Fire i mål i Berlin i oktober så tyder allt på att han ska stå sig väl även i detta lopp.</li>



<li><strong>Boke Palema </strong>galopperade bort en andra- eller tredjeplats utvändigt ledaren 50 meter före mål senast på Färjestad. Han har haft ett månadslångt uppehåll efter det och nu får Björn Goop chans till revansch bakom den så starke sjuåringen som höll emot Velten Swarovski när han kom till tät på Färjestad för tre starter sedan.</li>



<li><strong>Grappa Boy</strong> kvalade in till Breeders Crown-finalen i höstas, men blev sjuk och tvingades stå över det loppet. Han fick dålig utdelning under de efterföljande vinterstarterna, men känns inte helt ointressant i sin återkomst tillsammans med Örjan Kihlström.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>11-8-3-5 <strong>B: </strong>9-10-4-14-7-6 <strong>C: </strong>1-12-2-15</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Kirby Starlake</strong> tar säkert rygg på den av <strong>Demir K.M.E.</strong> och <strong>Boke Palema</strong> som kommer först. Vi tror att den sistnämnde är snabbare när han inte har någon häst på utsidan och kan &#8221;ta ut&#8221; sin plats mer. Från tillägg räknar vi med snabbstart från vår tipsetta <strong>Conch On Inn</strong>.</p>



<h2 class="wp-block-heading">Avd 2 – STL Champions &#8211; Stolopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>In Style</strong> blir vårt tipsval i detta vidöppna stolopp där vi placerat samtliga hästar i B-gruppen och med andra ord inte bedömer någon deltagare som chanslös. Vi tycker inte att det stämt positionsmässigt för In Style i de två starter hon har gjort för Joakim Lövgren utan hon har hamnat i ingemansland som förstahäst i andraspår båda gångerna i kvalificerade omgivningar efter att inlett från snäva startspår. Hamnar hon någorlunda vettigt till från det här utgångsläget har hon alla möjligheter att leverera ett starkt slutvarv för vi bedömer henne som urtypen som hellre jagar än blir jagad.</li>



<li><strong>Zelma de Castella </strong>trodde vi inte var någon märkvärdig häst, men hon har lyft flera snäpp i vinter. Trots att hon galopperade efter 100 meter i näst senaste starten hann hon fram till vinst via ett tufft slutvarv och senast på Färjestad gick hon en rejäl långspurt till vinst via 1.13 sista 800 meterna.</li>



<li><strong>Only Angelica O.C.</strong> var tvåa i ett Klass II-försök på Jägersro i näst senaste starten bakom Scala efter att avslutat 1.11,5 sista 700 meterna med en del tredjespår på vägen. Senast kördes hon avvaktande och fick chansen för sent för att hinna utmana <strong>Crowning Kronos</strong> om segern. Nu tror vi klart mer på den förstnämnda då vi bedömer galopprisken i voltstart som stor för Crowning Kronos.</li>



<li><strong>Sun Summit</strong> är spännande stammad med Maharajah som far och Stochampionatsvinnaren Some Summit som mor. Hon fick ganska tuffa resor vid fjolårets sista två starter och stod för starka insatser och när Jörgen Westholm tycks plussa för hennes träningsrundor så vill vi ha stoet högt upp i ranken.</li>



<li><strong>Silvertail </strong>har tre raka STL-starter bakom sig och såg obrukad ut över målgången senast efter ett smyglopp. Innerspår på tillägg behöver inte alls vara fel och vi gillar det faktum att Magnus A Djuse ska ratta stoet.</li>



<li><strong>Is This Love</strong> blir loppets favorit, men vi skickar ner henne som sexa i vår rank väl medvetna om att vi kan bli ståendes med dumstruten på. Vi tycker att segrarna är tagna i billiga sällskap, att hon inte visat prov på någon speciell startsnabbhet i voltstart och tyckte hon var blek när det blev mothugg i Kalmar näst senast.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>B: </strong>13-3-15-5-8-1-9-11-7-14-2-6-10-4-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Is This Love </strong>var inte när att fronta från innerspår på Åby i början av december och kan bli passerad av springspårshästarna direkt. <strong>Molly Vici </strong>öppnade bra från springspår i karriärens andra start och är knapp spetsfavorit.</p>



<h2 class="wp-block-heading">Avd 3 – STL Champions &#8211; Spårtrappa, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Strängnäs Palema</strong> slutade tvåa i Slaget vid Axevalla Hed som treåring samt femma i E3 Revanschen. Han visade prov på hög högstanivå och även om han inte frontade från just detta spår i Gävle den 4 augusti så bedömer vi honom som kvick ur groparna och med chans att antingen fronta av egen kraft eller ta över taktpinnen tidigt. Tävlingsuppehåll är inte optimalt, men det låter väl förberett från Hans Crebas.</li>



<li><strong>Carelya</strong> har varit i hysterisk vinterform och bärgat tre segrar på fem försök. Vid de två senaste segerloppen har hon fått blytunga slutvarv, men gnuggat på förstklassigt och visat härlig inställning. Vid senaste starten på Solvalla hamnade hon i en trött rygg, men kom tillbaka bra i vida spår och gick med ful fart över mål. Spår längst ut bakom vingen är dock ett orosmoln då hon inte visat prov på någon speciell startsnabbhet och det finns hästar i tre led som söker position.</li>



<li><strong>Beachcomber</strong> såg smällfin ut vid segern i Kalmar i början av januari då han forcerades till tät och höll emot med lätthet trots ett snabbt inledningsvarv. Joakim Lövgren valde att ta dödens dryga varvet före mål med sin häst i efterföljande start, men då var Beachcomber chanslös att hålla jämna steg med Tearsinheaven. Vi tycker det är svårt att bedöma vad man kan förvänta sig av hästen här, men tror att han duger bra om han presterar som vid segerloppet.</li>



<li><strong>Al Pacino</strong> gick en imponerade långspurt näst senast, men har inte fått något lopp i kroppen då han felade från start i comebacken. Al Pacino är &#8221;okej plus&#8221; från start och då han kan sitta långt fram i fältet direkt känns han skrällduglig.</li>



<li><strong>Gloster Gladiator</strong> tassade med lättsamt längs sargen som Klass I-sexa på Åby den 10 december och följde lika starkt bakom duktige Lovely Lasse gången efter. Han har många att runda från tredje ledet, men vi håller honom så pass högt att vi kan se det gå vägen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-8 <strong>B: </strong>4-5-15-12-13-11-3-14 <strong>C: </strong>9-7-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Strängnäs Palema</strong> får verkligen svettas ut om han ska hålla ut <strong>Special Topsecret</strong>, men vi tror det är möjligt. Om inte annat kan han säkert komma ut i skede två och överta ledningen efter 300-400 meter.</p>



<h2 class="wp-block-heading">Avd 4 – STL Champions, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Dynamite Sensation </strong>ställer vi som ensam A-häst i ett lopp med tunn bredd. Han forcerades till tät i ett Klass II-försök på Jägersro i november och höll undan säkert den dagen, men gick väl så bra som trea i finalen bakom Global Dubhe och H.C.&#8217;s Crazy Horse. Efter spetssegern på Åby satt han fast med rubbet sparat i vinnarhålet på Axevalla och har extrakrafter att plocka fram till detta lopp. Vi tror Carl Johan Jepson sätter allt på ett kort och tillmäter honom god chans att forcera hästen till tät från detta utgångsläge.</li>



<li><strong>Wingait Leif </strong>var tvåa samt trea i tvåa i lopp med sexsiffriga förstapris under senhösten. Han gick framförallt starkt på Sundbyholm som trea via 1.11,8 sista varvet efter att hamnat långt bak. Hästen kördes avvaktande i comebacken, men spurtade starkt som trea när luckan kom klockad till 1.11,5 sista 700 meterna. Det loppet för honom säkert framåt rejält och körande Stefan Persson visade så nyligen som i lördags bakom Heroine Darling att han vet hur man kommer till från bakspår på tillägg.</li>



<li><strong>Imola Boko</strong> tycker vi inte är någon storstjärna i grunden, men hästen tycks vara i sitt livs form just nu. Senast på Färjestad kunde han avvakta i andra utvändigt tills 400 meter återstod och då växlade han ner sina konkurrenter via 1.11,7 sista 700 meterna. Då som nu med Magnus A Djuse som kusk och det är givetvis en fördel att han åker ut med en häst som han känner har bevisad form.</li>



<li><strong>The Eagle</strong> var favorit i Imola Bokos segerlopp senast på Färjestad, men agerade spänt i voltstart och galopperade efter 50 meter. Faktum är att han även galopperade i sitt näst senaste voltlopp och här inleder han åter från snävt spår. Hästen har varit jättebra vid segerloppen och är en bättre häst än Imola Boko, men rankas efter på grund av galopprisken.</li>



<li><strong>Ozak Vivantis </strong>är en av omgångens mest svårbedömda hästar. Han har segrat i vardagslopp från tät, vinnarhålet respektive dödens och gjort det bra utan att det skrikit klass om hästen. Den här utmaningen är något helt annat och vi rankar ner den belgiske valacken.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>11 <strong>B: </strong>15-5-6-1-10-8 <strong>C: </strong>4-13-9-14-12-2-7-3</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Ozak Vivantis </strong>har bara gjort ett lopp i voltstart på svensk mark. Då inledde han i maklig takt och galopperade efter att blivit generad efter 50 meter. Vi tror chansen är stor att någon av de övriga hästarna på startvolten snuvar honom på tät och släpper till<strong> Dig For Ember </strong>eller <strong>Dynamite Sensation</strong> som lär öppna snabbt från tillägg.</p>



<h2 class="wp-block-heading">Avd 5 – STL Lärlingschampion, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Beauty Smart Face </strong>har vunnit hälften av sina åtta starter och vi håller henne för att vara ett stort löfte. Efter att galopperat från snävt startspår i comebacken på Åby dagarna före jul har stoet bärgat två raka segrar med lätthet efter att tidigt forcerats till tät från tillägg. Hon har sett okörd ut vid segrarna och det känns som hon tävlar i en på tok för låg klass kontra faktiskt kunnande. Det finns dock nerv i det här Ready Cash-stoet och vi skulle inte bli helt överraskade om hon gör bort sig, men i felfritt lopp är chansen mycket god att hon vinner det här loppet.</li>



<li><strong>Luv Lois Schermer </strong>har haft en växande segeraptit under vintern och står med fyra fullträffar på de fem senaste starterna. Han fick överta ledningen av X.Y.Diamant i Sverigedebuten och hade inga problem att hålla undan till vinst via 1.15,5 sista 1.500 meterna. Han vann även från tät gången innan i Wolvega, men backar vi bandet till starten i Gelsenkirchen på nyårsdagen så löste han sin uppgift från dödens på ett resolut vis. Förutsättningarna här är svåra från tredje ledet, men mycket talar för att hästen står billigt inne i loppet.</li>



<li><strong>Devs Donator </strong>har gjort två starter efter 13 månaders tävlingspaus. Han vann enkelt från ledningen i comebacken, men galopperade därefter mitt på upploppet efter en tripp i vinnarhålet utan att se allt för kaxig ut i det skedet. Två lopp i kroppen kan i vilket fall göra susen och på sin goda startsnabbhet talar allt för att han kommer sitta långt fram i fältet.</li>



<li><strong>Farbror Melker</strong> är inte enkel utan har nu galopperat i fyra av de fem senaste starterna. Senast på Åby felade han direkt, men det handlade om ett litet fält att jaga ikapp och han löste uppgiften med lätthet efter att placerats i dödens inför slutrundan. Vi håller hästen som en tuffing som ska gynnas av den dryga distansen och påminner om att han var spelad till under tio gånger pengarna i ett Klass II-försök i Halmstad kvällen före julafton.</li>



<li><strong>Walk Of Life </strong>avgjorde lätt från tredje invändigt på Åby när luckan kom perfekt 300 meter före mål. Han är stark och övertygade vid segern på Jägersro i november, men från spår åtta är vingelrisken i ett femtonhästarsfält påtaglig.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>10 <strong>B: </strong>14-5-15-8-9-1-12 <strong>C: </strong>11-13-7-3-2-4-6</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Kung Carl Autriche </strong>öppnade bra för tre starter sedan, men innerspår är lömskt och vi tror att han får svårt att hålla ut <strong>Devs Donator</strong>. <strong>Beauty Smart Face</strong> har rygg på två relativt långsamma hästar, men skulle hon avanceras fram i tidigt skede är det sannolikt att hon får överta ledningen.</p>



<h2 class="wp-block-heading">Avd 6 – STL Champions &#8211; Stolopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Zola Love </strong>har blott en start i sig under de senaste nio månaderna, men det var verkligen en plusbetonad återkomst som hon stod för. Numera finns hon hos Kalmartränaren Thomas Madsen och för honom började hon med en vattentät spetsseger på hemmaplan efter att avslutat 1.12,5 sista 700 meterna och gått i mål med fin spänst. Från ledningen är hon hästen att slå för de övriga.</li>



<li><strong>Nina Ginto </strong>löste en liknande uppgift på Solvalla i slutet av november. Nu får hon starta för andra lördagen i rad och det tror vi inte ska vara något problem då hon fick chansen på tok för sent ur tredje invändigt i Stoeliten på Solvalla för att hinna köras i botten. I de två starter hon gjort dessförinnan har hon levererat vassa avslutningar och vi har ingen anledning att tro att det är något fel på formen.</li>



<li><strong>Sanibel </strong>startar för tredje lördagen i följd och ska nu försöka hålla sig på mattan efter att galopperat från start efter kort därefter i de två senaste loppen. Näst senast gick hon en stark upphämtning via 1.14,7 sista 1.900 meterna och det kan vara gynnsamt för henne att slippa ha en stressframkallande konkurrent på utsidan från start.</li>



<li><strong>Ess Mahatma </strong>satt fast med rubbet sparat i näst senaste starten och vann därefter lekande lätt från ledningen. Hon såg stark ut i det loppet och är inte utan chans här heller även om det knappast blir tät.</li>



<li><strong>Orlando </strong>har körts avvvaktande i de två senaste sulkystarterna på fransk mark. Senast sköt hon till helt okej som trea via tredje invändigt i Saint-Galmier och det är fullt möjligt att hon får en nytändning nu när hon är tillbaka på tusenmetersbana.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-14 <strong>B: </strong>12-4-15-2-13-3-7-5-10-9 <strong>C:</strong> 1-11</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi är helt inne på att raska<strong> Zola Love</strong> piper till tät från springspår när hon rattas av en kusk som vet hur man prickar från sådana här utgångslägen. <strong>Lilo Love</strong> och <strong>Lazy Breeze </strong>slåss om att få rygg på Zola Love.</p>



<h2 class="wp-block-heading">Avd 7 – STL Champions, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Indigo</strong> håller vi som spetsberoende i den här höga klassen och hade därför rankat ner senast i Halmstad när vi inte trodde att han skulle fronta från spår sju bakom bilen. Den dagen kastade han sig i galopp direkt bakom bilen och var borta direkt, men gången innan forcerades han till just tät – trots tillägg – efter 250 meter och vann enkelt. Det finns motbud i spetskampen, men vi håller honom som spetsfavorit och i sådana fall är han hästen att slå för de övriga.</li>



<li><strong>Without A Doubt</strong> fick långt fram senast i Halmstad, men avslutade riktigt starkt som fyra och gick med full fart över mål. Även han har haft ett rykte om sig att vara spetsberoende, men det är läge att tona ner det snacket och inse att så inte är fallet. Han har rygg på en startsnabb häst och kan hamna långt fram i fältet trots bakspår.</li>



<li><strong>Gerben</strong> löste det sig inte alls för senast i Halmstad och hästen hade på tok för långt fram för att kunna utmana om segern när han fick fritt spurtutrymme i vida spår. Av avslutningen att döma så kvarstår formen och Gerben var verkligen samlat ihop till en lördagstriumf.</li>



<li><strong>Starbec&#8217;s A.To Z. </strong>avslutade rykande längs open stretch i näst senast starten och gick därefter runt sina konkurrenter sina 800 meterna i Örebro trots att Anders Svanstedt inte var helt tillfreds med hästens bråkiga beteende den dagen. Av det får han ingenting visa denna gång om det ska gå vägen från spår fem, men i felfritt lopp är hästen med och gör upp om segern.</li>



<li><strong>Pere Ubu </strong>har fått två lopp i kroppen efter lång frånvaro och såg inte helt tom ut över målgången senast i Silverdivisionen. Han var framme som tredjehäst efter 100 meter från spår tolv i voltstart i våras och brukar trivas allra bäst i tät så skulle Stefan Persson lyckas hålla ut Indigo från början så kan vi se honom testa i den positionen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-9-11 <strong>B: </strong>5-4-3-1-8-10-14-7-13 <strong>C: </strong>2-15-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Indigo</strong> är riktigt rappt ur groparna ur voltstart och är spetsfavorit från springspår. På hans insida kan dock <strong>Herakles</strong>, <strong>King of Everything </strong>och framförallt <strong>Pere Ubu </strong>även lägga iväg och skulle den sistnämnda lyckas hålla ut så tror vi att han körs i ledningen.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									V75-FÖRSLAGET 11 FEBRUARI								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>Avd 1: </strong>3,5,8,11 (9,10)<br /><strong>Avd 2: </strong>Samtliga 15 hästar (13,3)<br /><strong>Avd 3: </strong>1,4,5,8,12,15 (13,11)<br /><strong>Avd 4: </strong>11 Dynamite Sensation (15,5)<br /><strong>Avd 5: </strong>10 Beauty Smart Face (14,5)<br /><strong>Avd 6: </strong>6,14 (12,4)<br /><strong>Avd 7: </strong>3,4,5,6,9,11 (1,8)</p>
<p class="wp-block-paragraph"><em>4.320 rader / 2.160 kronor</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
